This post continues a previous teardown of Prime Agent's architecture (19.5k★, a single IPython tool). The open question was the top-voted Hacker News criticism: that RLM's "recursion" wins only because the root uses a top-tier model while sub-calls use a cheap model — meaning recursion itself deserves no credit. This article 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 HN discussion threads. 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 community opportunism.
1. HN Criticism Verdict Table
| Claim | Source | Verdict | |---|---|---| | "Recursion wins because root = top model + sub-agents = 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 ("cost balance" verbatim), but the uniform-model headline results refute this being the cause of the win | | "RLM is just academic CodeAct wrapped up" | Same | Wrong — per the paper, RLM beats CodeAct with sub-calls by 130%. Same "write code + recursive sub-calls" structure, vastly different structural discipline | | "The repo itself is LLM bloat code" (10K LOC files / 1000-line switch) | HN user embedding-shape | Unverified (engineering aesthetics; doesn't affect attribution) | | "PrimeIntellect isn't on the official ARC-AGI-3 leaderboard" | HN user tintor | True — and the paper itself says the references "situate results rather than isolate causal effects," more honest than the critics |
2. Five Ablation Groups: How Much Does Recursion Contribute?
Group 1 (uniform-model headline): RLM(GPT-5-mini) wins with all-GPT-5-mini. Per Zhang's blog: on OOLONG trec_coarse at 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 under conditions where model asymmetry doesn't exist. This is the most direct counterexample to oofbey.
Group 2 (de-recursion ablation): depth=0 loses only ~10%. Paper notation RLM(model, depth=N): depth=0 = REPL present but sub-calls banned. On OOLONG, removing recursion costs about 10% (blog); on BrowseComp-Plus at thousand-document scale, the no-recursion ablation still scores 90% (RLM(GPT-5) full marks at 100%).
Group 3 (counterexample): recursion is harmful on CodeQA. Paper verbatim: on CodeQA, RLM(depth=0) with Qwen3-Coder-480B beats all recursive variants — in coding tasks, sub-calls are a burden, not a boost.
Group 4 (positive case): recursion is essential on information-dense tasks. On OOLONG-Pairs (pairwise semantic-relation aggregation), depth=1 RLM(GPT-5) decisively 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 paper describes the mechanism as "constructing the problem as a graph, programmatically traversing the reasoning graph, and solving node-by-node via sub-calls."
Group 5 (mechanism strike): without recursion, forced into keyword heuristics. Paper trajectory analysis verbatim: on information-dense tasks, recursive RLM performs semantic transformations line by line, while the no-sub-call ablation "was forced to use keyword heuristics." This explains the essence of the 10% gap: 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, Transmission, Fuel Saver
Putting the five groups together, the attribution structure is clear:
Layer 1 (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 via code — turning "passive attention over a fixed sequence" into "programmatic information management." This layer contributes most of the gain (de-recursion costs only 10%), and the interface preserves structure (a list/dict in Python is a list/dict) — the positive mirror of "interfaces that lose structure": narrow predicate interfaces lose structure and semantics, the REPL interface hands both to the model.
Layer 2 (transmission): recursion is a task-gated decomposition strategy. Recursion's value is gated by task structure: retrieval tasks (BrowseComp-Plus) → near-zero gain; coding (CodeQA) → negative; information aggregation (OOLONG +10%) and combinatorial reasoning (PARC +69.5%) → positive. The paper's task-complexity taxonomy explains it: S-NIAH is constant complexity, OOLONG linear, OOLONG-Pairs quadratic — recursion's value grows with task-complexity slope. This is why the name "recursion" itself oversells: it's a transmission; you only shift gears when climbing (dense semantics).
Layer 3 (fuel saver): model mixing is cost optimization, not a capability source. The default config of GPT-5 root + GPT-5-mini leaves exists (paper: "balance of capabilities and cost"), but the uniform-model results prove it doesn't remove the gain — it removes the bill. Attribution-wise it's a fuel saver: making every gear shift cheaper, so more shifts per 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, a median +28%, approaching bare GPT-5 on three long-context tasks with 3× faster inference and lower cost. Two key findings: (1) training on one LongBenchPro domain generalizes across all evaluated tasks; (2) RLVR trained at 64k/2-needle generalizes to 1M/8-needle (length generalization). A quotable line: "becoming a good sub-call model is roughly equivalent to becoming a general reasoning model" — this elevates "recursive structure" from a harness trick to a trainable model capability. If models start being trained around the REPL (as they were around chat formats and CoT), layers 1 and 2 shift from prompt engineering to endogenous weights.
5. The Prime Agent Side's Honest Boundaries: The Paper Disarms Before the Critics
Back to that 30% → 95.5% number. The paper's evaluation section limitation, worth quoting in full: "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 isn't stated in the text (it appears in Figure 5); the HN thread cites PrimeIntellect's official X post claiming 95.5% was achieved by GLM-5.2. Another self-disarm: the nanoGPT experiment concludes that "harness choice affects the final record less than experimental noise" — only the model's behavior changed (simulating candidate optimizers in the REPL with synthetic gradients, numerically optimizing update-rule coefficients before running training). An evaluation paper openly writing "our reruns of others' official harnesses scored below their self-reported numbers" is a rare high-water mark in evaluation-honesty terms.
Editor's Note
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 interface switch from context-as-string to context-as-environment — the same coin as the previous post's "tool menu collapsing into a language": menu collapse solves "how the model acts," context environmentization solves "how the model knows." Recursion itself is a second-order, task-gated strategy (necessary for information-dense/combinatorial reasoning, harmful for coding, near-zero for retrieval), and model mixing is third-order cost optimization. The HN criticism is factually wrong (uniform models still win) but narratively hit the mark — the word "recursion" lets a second-order strategy take credit for a first-order interface.
The fourth layer is what to watch: RLM-Qwen3-8B proves "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 paper 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 factory default, like "models understand instructions."
---
*Verification notes: the five ablation groups come from the arXiv 2512.24601v3 HTML full text and Alex Zhang's blog (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 HN comments (x.com/PrimeIntellect/status/2085087000764568010), not stated in the paper text, shown in Figure 5, X original not directly verified.*