Academia is for Ambition — Alex Zhang, MIT

What it claims

Alex Zhang argues that today's coding harnesses (Claude Code, Codex, Pi) share nearly the same design: "trajectory as a prompt," where the whole rollout stays in the main model's context. They argue that a different harness design, the Recursive Language Model (RLM), improves compositional generalization. In this design, a model trained on one task can transfer the same high-level strategy to longer tasks or to different-looking tasks. Zhang says RLMs trained on short tasks generalize to tasks 8–30x longer. They also report transfer between unrelated tasks, such as retrieval to aggregation and math to writing, because the top-level strategy is the same even when the subtasks differ.

How it works

Zhang gives this definition, which they say they "wish I had in the original paper":

• The harness has one tool: code (a Python or Bash REPL).
• The model can call itself as a function from that code (programmatic subagent calls), and other tools are also exposed as functions.
• The context is offloaded into memory inside the code environment, such as variables or a file system. It does not sit in the prompt.

Subagents solve easier subtasks, so the root model's strategy looks the same across problems. Zhang says this argument applies recursively at each level.

flowchart TD
  Q[Task] --> R[Root LM writes code]
  R --> M[(Offloaded context in REPL memory / disk)]
  M --> R
  R --> S{Subtask?}
  S -->|yes| C[Call RLM recursively on subtask]
  C --> R
  S -->|no| A[Return answer]

Prime Agent is a partial version of this design. Its trajectory is stored on disk, so the model can reference its original context even after compaction, and its only tool is IPython. It still keeps the standard compacting trajectory-as-prompt loop.

Evidence

• The 8–30x length generalization and the cross-task transfer come from Zhang's "harnesses are compositional generalizers" blog post, which is discussed but not reproduced on this page. No baselines or settings are given here.
• Zhang says they have unpublished results showing that Pi and Claude Code "distinguish too much" between tasks that have the same solution.
• On RLM performance by model, Zhang reports that "Fable for a long time was the best model for RLMs" because it was trained on dynamic workflows, and that Astra is now good enough. Zhang states these are internal, non-public results.
• For AI-written GPU kernels, nearly all recent GPU Mode leaderboard solutions are AI-generated. One kernel in the top 10 was steered by an expert human, and it was reportedly the only one that stayed stable in end-to-end systems. Zhang cites reward hacking as a known KernelBench problem.

Limits

• Current models are not trained for RLM workflows. Plugged into an RLM, they are "okay," not good. Zhang says the real value depends on training the system properly, which is ongoing work.
• RLMs are slow. Many sequential LM calls misallocate compute. Zhang suggests cheap non-autoregressive models such as Jev for trivial subcalls.
• Kernel leaderboard results are not proof of usable kernels. Verification is a stated gap. Megakernel generation lacks training data, and Zhang expects compilers to handle fusion better.
• Supporting evidence is outside this page. Most quantitative claims are in the external blog post, in an "harness tax" paper attributed to Arena (which Zhang says found most harness choices don't matter), or in internal results.
• Only part of the page was available. This analysis covers the first ~60k of ~127k characters. The sections on RLMs in the wild, OpenAI's 10,000-agent / 130B-token (~$40M-equivalent) experiment, Kimi vs. OpenAI swarms, speculative programmatic tool calling, and Neuralese appear only in the episode outline and were not seen.