Recursive Agent Harnesses
This paper introduces the Recursive Agent Harness (RAH), a code-first framework where parent agents spawn parallel subagent harnesses with filesystem and execution tools, demonstrating significant improvements in long-context reasoning and coding tasks over traditional model-recursion baselines when evaluated with fixed and stronger backbone models.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you have a massive library containing millions of books, and you need to find a specific fact in every single one of them.
The Old Way: The Overworked Librarian
Previously, if you asked a smart AI (a "coding agent") to do this, it would try to act like a super-fast librarian. It would scan the books using simple rules (like looking for specific keywords) to find answers. But because the library is so huge, the librarian can only hold a few books in their hands at once. They have to skip reading the actual text of most books and rely on those simple rules. If the answer requires deep thinking about a specific page, the librarian misses it.
The "Model Recursion" Way: The Chain of Thought
Another approach, called "Recursive Language Models" (RLMs), tried to solve this by breaking the library into smaller piles. The AI would think about one pile, then the next, then the next, in a long chain of thought. However, this AI is like a librarian who is forbidden from touching the books. They can only think about the text they are given but cannot open the files, run tools, or use a magnifying glass. They are smart but helpless without the actual tools to interact with the documents.
The New Way: The "Recursive Agent Harness" (RAH)
This paper introduces a new strategy called the Recursive Agent Harness (RAH).
Think of RAH not as one librarian, but as a master contractor who builds a whole new team for the job.
- The Master Plan: The main AI (the parent) looks at the massive library and realizes, "I can't do this alone, and I can't just think about it."
- Writing the Script: Instead of trying to do the work itself, the parent writes a computer program (a script). This script is like a set of instructions that says: "For every single book in this library, hire a new, fully equipped assistant."
- The Sub-Teams: The script runs and instantly spawns hundreds of sub-agents. Crucially, each of these sub-agents is a full worker. They have their own desk, their own tools (like file openers, search engines, and code executors), and their own context window (their own mental space).
- Parallel Work: While the old librarian could only look at one book at a time, and the chain-of-thought AI could only think about one pile at a time, RAH sends out thousands of these fully-equipped assistants to work on their specific books all at the same time.
- The Result: Each assistant reads their specific book, uses their tools to find the answer, and writes the result down. The parent then collects all the answers.
The Analogy of the "Toolbox"
The key difference is the toolbox.
- The Coding Agent has a toolbox but can only look at a few books at once.
- The RLM has a huge brain but no toolbox; it can't open the files.
- RAH gives every single worker their own full toolbox and lets them work in parallel.
What the Paper Found
The researchers tested this on a very difficult test called "Oolong," which involves finding answers in documents as long as 4 million words (roughly the size of a small novel, but with thousands of entries).
- They used the same "brain" (GPT-5) for all the tests to make it a fair comparison.
- The old "Coding Agent" got about 72% correct.
- The "Model Recursion" (no tools) got about 64% correct.
- The new RAH method got 81% correct.
The Takeaway
The paper claims that the improvement didn't come from using a smarter AI model. It came entirely from changing how the work is organized. By turning the "recursive unit" (the thing that repeats the work) from a simple "thought" into a "full worker with tools," the system became much better at solving complex, large-scale problems.
The authors note that this isn't just a theory; it's similar to how some real-world production systems (like Anthropic's dynamic workflows) are already starting to work. They simply gave this pattern a name and proved it works better than the old ways.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.