> [Editor's note] This is an English translation of a Chinese tech-forum deep-dive. All arXiv IDs, URLs, and figures are preserved as in the original post.
The previous post dissected Prime Agent's architecture (19.5k★, a single IPython tool) and left one loose end: the top HN comment claimed RLM's "recursion" wins only because "the root uses a top model while sub-calls use cheap models" — that recursion itself deserves no credit. This post digs that attribution question to the bottom. Sources: the original RLM paper (arXiv 2512.24601, Zhang/Kraska/Khattab, MIT, v1 2025-12-31 → v3 2026-05-11), first author Alex Zhang's blog post, the evaluation chapter of the Prime Agent paper (2608.23552), and the HN discussion thread. First, the lineage: Prime Agent's second author, Alex L. Zhang, is the first author of the RLM paper — Prime Agent is the productized continuation by the RLM paper's own author, not a community imitation.
1. Verdict table on the HN objections
| Claim | Source | Verdict | |---|---|---| | "Recursion wins because root = top model + sub-agents = cheap models" | HN user oofbey | Right about the config, wrong about the mechanism — the paper's default is indeed GPT-5 root + GPT-5-mini recursive calls ("cost balancing" verbatim), but the uniform-model headline result refutes this being the cause of the win | | "RLM is just academic CodeAct wrapped up" | Same | Wrong — per the paper's median numbers, RLM beats CodeAct with sub-calls by 130%. Same ingredients (code + recursive sub-calls), vastly different structural discipline | | "The repo itself is LLM bloat code" (10K LOC files / 1000-line switches) | HN user embedding-shape | Unverified (engineering aesthetics; doesn't affect the attribution conclusion) | | "PrimeIntellect isn't on the official ARC-AGI-3 leaderboard" | HN user tintor | True, and the paper itself says the external reference lines "situate results rather than isolate causality" — more honest than the skeptics |
2. Five ablation groups: how much does recursion actually contribute?
Group 1 (uniform-model headline): RLM(GPT-5-mini) wins with all-GPT-5-mini. From Zhang's blog: on OOLONG trec_coarse with 132k tokens, RLM(GPT-5-mini) beats bare GPT-5 by 34 points (+114%) at comparable cost. Root and sub-calls are the same cheap model — the gain appears even when model asymmetry is eliminated. This is the most direct counterexample to oofbey.
Group 2 (recursion-removal ablation): depth=0 loses only ~10%. Paper notation RLM(model, depth=N): depth=0 = REPL present but sub-calls forbidden. On OOLONG, removing recursion drops performance ~10% (blog verbatim); at BrowseComp-Plus's thousand-document scale, the no-recursion ablation still gets 90% (RLM(GPT-5) full score: 100%).
Group 3 (counterexample): recursion is harmful on CodeQA. Paper verbatim: on CodeQA, RLM(depth=0) with Qwen3-Coder-480B beats every recursive variant — on coding tasks, sub-calls are a burden, not a boost.
Group 4 (positive case): recursion is a necessity for information-dense tasks. On OOLONG-Pairs (pairwise semantic-relation aggregation), RLM(GPT-5) at depth=1 leads all methods including Claude Code and OpenCode; on the PARC combinatorial problem, RLM(GPT-5.2, depth=1) beats bare GPT-5.2 by 69.5% — the described mechanism is "formulate the problem as a graph, programmatically traverse the reasoning graph, solve node by node with sub-calls."
Group 5 (mechanism evidence): without recursion, the model falls back to keyword heuristics. Paper trajectory analysis verbatim: on information-dense tasks, recursive RLMs perform semantic transformations line by line, while the no-sub-call ablation "is forced to use keyword heuristics." This explains the essence of the 10% gap: the REPL provides programmatic access; recursion provides semantic decomposition — the former handles "how to get the data," the latter "how to understand the data."
3. Three-layer attribution: engine, gearbox, fuel saver
Putting the five groups together, the attribution structure of the gains is clear:
Layer 1 (the engine): context goes from string to environment. RLM's defining move is storing the prompt in a REPL variable so the model can examine/decompose/filter/aggregate with code — from "passive attention over a fixed sequence" to "programmatic information management." This layer contributes most of the gain (removing recursion only costs 10%), and the interface preserves structure (a list/dict in Python is a list/dict) — the positive mirror image of "interfaces that lose structure": narrow predicate interfaces shed structure and semantics, while the REPL hands both to the model.
Layer 2 (the gearbox): recursion is a task-gated decomposition strategy. Its value is gated by task structure: near-zero gain on retrieval (BrowseComp-Plus), negative on coding (CodeQA), positive on information aggregation (OOLONG +10%) and combinatorial reasoning (PARC +69.5%). The paper's task-complexity taxonomy frames it: S-NIAH is constant complexity, OOLONG linear, OOLONG-Pairs quadratic — the value of recursion grows with the task-complexity slope. This is why the name "recursion" oversells it: it's a gearbox you only shift when climbing (dense semantics).
Layer 3 (the fuel saver): model mixing is cost optimization, not a capability source. The default GPT-5 root + GPT-5-mini leaves config exists (paper verbatim: "a balance of capabilities and cost"), but the uniform-model result proves it doesn't add gains — it shrinks bills. In attribution terms it's a fuel saver: making every gearbox shift cheaper, so more shifts fit in the same budget.
4. The underrated fourth layer: structure can be trained into the model
The paper's most forward-looking part is RLM-Qwen3-8B — the first model post-trained around RLM structure: rejection fine-tuning of Qwen3-8B on 1,000 filtered trajectories distilled from Qwen3-Coder-480B, median +28%, approaching bare GPT-5 on three long-context tasks with 3x faster inference and lower cost. Two key findings: (1) training on one domain of LongBenchPro generalizes across all evaluated tasks; (2) RLVR trained on 64k/2-needle generalizes to 1M/8-needle (length generalization). A quote worth copying: "being a good sub-call model is roughly equivalent to being a general reasoning model." This upgrades "recursive structure" from a harness trick to a trainable model capability. If models start being trained around the REPL (as they were around dialogue formats and CoT), layers 1 and 2 shift from prompt engineering to being endogenous in the weights.
5. On the Prime Agent side: the paper disarms before its critics
Back to that 30% → 95.5% number. The evaluation chapter's limitation is worth quoting in full: "reference lines and points are external official values — our native harness reruns fall below published scores, so they are used to situate results rather than isolate a causal harness effect." Model attribution is not stated in the body text (it appears in Figure 5); the HN comments cite PrimeIntellect's official X post claiming GLM-5.2 achieved 95.5%. Another act of self-disarmament: the nanoGPT experiment concludes that "harness choice affects the final record less than experimental noise" — only the model's behavior changed (simulating candidate optimizers with synthetic gradients inside the REPL, numerically optimizing update-rule coefficients before running training). An evaluation paper proactively writing "our reruns of others' official harnesses score below their self-reported numbers" is a rare high-water mark in evaluation-standards lineage.
Editor's observations
The final answer to the attribution question in one sentence: RLM's victory is an interface victory packaged as "recursion." The real mechanism is the context-as-string → context-as-environment interface switch — two sides of the same coin as the previous post's "tool menu collapsing into a language": the menu collapse solves "how the model acts," context-as-environment solves "how the model knows." Recursion itself is a task-gated second-order strategy (necessary for information-dense/combinatorial reasoning, harmful for coding, near-zero for retrieval); model mixing is a third-order cost optimization. The HN criticism is factually wrong (uniform models still win), yet narratively it lands a lucky punch — the word "recursion" lets a second-order strategy take credit for a first-order interface.
More worth watching is the fourth layer: RLM-Qwen3-8B proves that "training models around REPL structure" is already feasible, and the authors explicitly call it a candidate for "the next inference-time scaling milestone after CoT reasoning models and ReAct agents." Combined with Prime Agent turning the RLM author's academic structure into a 19.5k★ industrial harness, this "paper → open source → training paradigm" conveyor belt is running at full speed. A falsifiable prediction: within 12 months a frontier model will ship trained with RL around REPL structure (base training, not fine-tuning), at which point "models understand code environments" will become a factory default, like "models understand instructions" already is.
---
*Verification note: the five ablation datasets come from the arXiv 2512.24601v3 HTML full text and Alex Zhang's blog post (fetched 2026-09-02); Prime Agent data from 2608.23552v1 HTML full text; HN comments from hn.algolia.com item 49189075; "GLM-5.2 achieved 95.5%" comes from the PrimeIntellect X post cited in the HN comments (x.com/PrimeIntellect/status/2085087000764568010), not stated in the paper body, shown in Figure 5, and not independently verifiable from the original X post.*