> The previous post dissected Prime Agent's architecture (19.5k stars, a single IPython tool) and left one thread hanging: the top-voted HN objection argued that RLM's "recursion" wins only because "the root uses a top model while sub-calls use a cheap model"—so 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 section of the Prime Agent paper (2608.23552), and the HN discussion tree. First, the lineage: Alex L. Zhang, second author of the Prime Agent paper, is the first author of the RLM paper—Prime Agent is the productized continuation by the RLM paper's own author. This is not community opportunism; it is direct descent.
1. Verdict Table for the HN Objections
| Claim | Source | Verdict | |---|---|---| | "Recursion wins because root = top model + subagents = cheap model" | HN user oofbey | Right about the configuration, wrong about the mechanism—the paper's default config is indeed GPT-5 root + GPT-5-mini recursive calls (the paper's phrase: "cost balance"), but the uniform-model headline result refutes "this is why it wins" | | "RLM is just an academic CodeAct wrapper" | Same user | Wrong—per the paper, RLM beats CodeAct with sub-calls by 130% on median. Same ingredients (write code + recursive sub-calls), vastly different structural discipline | | "The repo itself is LLM-bloated code" (10K-LOC files / 1000-line switch) | HN user embedding-shape | Unverified (an engineering-aesthetics issue; does not affect the attribution conclusion) | | "PrimeIntellect is not on the official ARC-AGI-3 leaderboard" | HN user tintor | True—and the paper itself states the reference line "situates results without isolating causality," more honest than the critic |
2. Five Ablation Groups: How Much Does Recursion Actually Contribute?
Group 1 (uniform-model headline): RLM(GPT-5-mini)—all GPT-5-mini—still wins. From Zhang's blog: on OOLONG trec_coarse at 132k tokens, RLM(GPT-5-mini) beats vanilla GPT-5 by 34 points (+114%) at comparable cost. Root and sub-calls are the same cheap model—the gains persist even when model asymmetry is eliminated. This is the most direct counterexample to oofbey.
Group 2 (recursion-removed ablation): depth=0 loses only ~10%. The paper's notation RLM(model, depth=N): depth=0 = REPL present but sub-calls forbidden. On OOLONG, removing recursion costs roughly 10% (per the blog); on BrowseComp-Plus at thousand-document scale, the no-recursion ablation still achieves 90% (RLM(GPT-5) scores 100%).
Group 3 (counterexample): recursion is harmful on CodeQA. Paper, verbatim: on CodeQA, Qwen3-Coder-480B's RLM(depth=0) beats all recursive variants—on coding tasks, sub-calls are a burden, not a boost.
Group 4 (positive case): recursion is a necessity on 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 vanilla GPT-5.2 by 69.5%—the paper describes the mechanism as "constructing the problem as a graph, programmatically traversing the reasoning graph, solving node-by-node via sub-calls."
Group 5 (mechanism, direct hit): without recursion, the model is forced into keyword heuristics. Paper trajectory analysis, verbatim: on information-dense tasks, recursive RLM performs per-line semantic transformations, 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. Attribution in Three Layers: Engine, Gearbox, Fuel Saver
Putting the five groups together, the attribution structure is clear:
Layer 1 (engine): context moves 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—"passive attention over a fixed sequence" becomes "programmatic information management." This layer contributes most of the gain (removing recursion costs only 10%), and the interface loses no structure (a Python list/dict is a list/dict)—the positive mirror image of the "interfaces that drop structure" thesis: narrow predicate interfaces drop structure and semantics; the REPL interface hands both to the model.
Layer 2 (gearbox): recursion is a task-gated decomposition strategy. Recursion's value is gated by task structure: retrieval tasks (BrowseComp-Plus) → gains near zero; coding tasks (CodeQA) → negative; information aggregation (OOLONG, +10%) and combinatorial reasoning (PARC, +69.5%) → positive. The paper's task-complexity taxonomy provides the frame: S-NIAH is constant complexity, OOLONG linear, OOLONG-Pairs quadratic—recursion's value grows with the task-complexity slope. This is why the name "recursion" itself oversells: it is a gearbox, only needed when climbing (dense semantics).
Layer 3 (fuel saver): model mixing is cost optimization, not the source of capability. The default GPT-5 root + GPT-5-mini leaves do exist (the paper's phrase: a balance of "capabilities and cost"), but the uniform-model result proves mixing does not reduce gains—it reduces the bill. Attributionally it is a fuel saver: it makes each gear shift of the gearbox cheaper, allowing more shifts at the same budget.
4. The Underestimated 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, yielding a +28% median gain, approaching vanilla GPT-5 on three long-context tasks while running 3x faster and cheaper. Two key findings: (1) trained on one LongBenchPro domain, it generalizes cross-domain to all evaluated tasks; (2) RLVR trained at 64k/2-needle generalizes to 1M/8-needle (length generalization). The paper's sentence is worth quoting: "becoming a good sub-call model is roughly equivalent to becoming a general reasoning model"—this upgrades "recursive structure" from a harness trick to a trainable model capability. If models begin training around the REPL the way they once trained around dialogue formats and CoT, Layers 1 and 2 will move from prompt engineering into the weights.
5. Prime Agent's Honest Boundaries: The Paper Disarms Before Its Critics Do
Back to that 30%→95.5% number. The evaluation section's original caveat deserves full quotation: "the reference lines and points are external official values—our native-harness reruns scored below the published numbers, so they situate the result rather than isolate a causal harness effect." Model attribution is not stated in the main text (it appears in Figure 5); the HN thread cites PrimeIntellect's official X post claiming the 95.5% was achieved by GLM-5.2. Another self-disarmament: the nanoGPT experiment's conclusion is that "harness choice has less impact on the final record 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-honesty terms.
Editorial Observation
The final answer to the attribution question in one sentence: RLM's victory is an interface victory dressed up as "recursion." The real mechanism is the interface switch from context-as-string → context-as-environment—the two sides of the same coin as the previous post's "tool menu collapsing into a language": menu collapse solves "how the model acts," context-as-environment solves "how the model knows." Recursion is a second-order, task-gated strategy (necessary for information-dense/combinatorial work, harmful for coding, near-zero for retrieval); model mixing is a third-order cost optimization. The HN critique is factually wrong (uniform models still win) but narratively lands a lucky punch—"recursion" as a word lets a second-order strategy take credit for a first-order interface.
What is more worth watching is Layer 4: RLM-Qwen3-8B proves that "training models around REPL structure" is already feasible, and the authors explicitly name 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-star industrial harness, the "paper → open source → training paradigm" conveyor belt is running at full speed. A falsifiable prediction: within 12 months a frontier model will ship with RL around REPL structure (base training, not fine-tuning); at that point "the model understands code environments" will become a factory default, like "the model understands instructions."
---
*Verification note: the five ablation groups come from the arXiv 2512.24601v3 HTML full text and Alex Zhang's blog post (fetched 2026-09-02); Prime Agent data comes from 2608.23552v1 HTML full text; HN comments from hn.algolia.com item 49189075; the claim "GLM-5.2 achieved 95.5%" comes from an HN comment citing PrimeIntellect's X post (x.com/PrimeIntellect/status/2085087000764568010), not stated in the paper's main text, shown in Figure 5, and not directly verified against the original X post.*