We need to talk about how we’re building AI agents. For the last year, the standard advice for handling long-context tasks has been “just use a bigger context window” or “stuff more into the RAG pipeline.” That’s a junior-level mistake that’s killing performance and blowing through token budgets. If you’ve ever watched a 128k context model lose its mind trying to find a specific logic bug in a massive codebase, you know exactly what I mean.
Most frameworks like ReAct or CodeAct treat context like a buffer that you just keep appending to. Eventually, you hit a race condition between memory and reasoning. Recursive Language Models (RLMs) are different because they finally introduce a concept we’ve used in software for decades: Pass by Reference.
The Architect’s Critique: Why Your Current Agent is Slow
In a standard agentic harness, whether you use ReAct or CodeAct, the model has to “read” everything to “know” everything. If you ask an agent to summarize 300 logs, it reads the logs, generates a thought, and then outputs a response. If that response includes the original data, it has to regenerate those tokens. It’s expensive, slow, and prone to hallucinations.
Recursive Language Models solve this by operating inside a REPL (Read-Eval-Print-Loop). Instead of the harness feeding the model the entire prompt, the model is given a pointer to the data. It decides what to read, what to slice, and how to store intermediate results in variables that persist across turns.
I recently wrote about building a pragmatic agentic AI workflow for WordPress, but RLMs take that a step further by decoupling the model’s “memory” from its “context window.”
How RLMs Handle Long Context Without “Rot”
When you use an RLM, the environment (usually something like Deno or Pyodide) exposes a context variable. The model doesn’t see the content of that variable until it explicitly calls print(context[:500]). This is huge for performance. Specifically, it allows for three things:
- Programmatic Exploration: The model can run regex or pandas operations on the data directly in the REPL.
- Variable Composition: Subagents return Python variables, not text. The parent agent can use a result without ever “reading” it into its own context.
- Arbitrary Output Length: Since the result is a variable in the environment, you aren’t limited by the model’s completion token limit.
Here is a comparison of how a traditional agent handles a “categorization” task vs. how Recursive Language Models approach it.
# Traditional CodeAct Approach
# The model must read all data and manually rewrite the JSON.
def process_logs(logs):
# LLM reads 1MB of logs...
# LLM hallucinates half-way through the 5,000 line JSON output.
return formatted_json
# RLM Approach (The "Pass by Reference" Logic)
# The model writes code to handle the heavy lifting.
```repl
import json
# context is already in the environment
results = await llm_query("Extract errors from context")
# results is a Python list variable, not a string in the prompt
FINAL(results)
```Why This Matters for WordPress Developers
Think about auditing a massive WooCommerce site with 100+ active plugins. If you try to feed that codebase into a standard LLM, you’ll hit “Context Rot” fast. The model starts forgetting the hook definitions it read at the beginning. By using Recursive Language Models, you can instruct the agent to recursively map the directory structure, store function definitions in a dictionary, and only “peek” at the source code of specific functions when needed.
Furthermore, you should build a persistent AI context layer to ensure these variables aren’t lost between sessions. This architecture is exactly how we scale from “cool demo” to “production-grade tool.”
Look, if this Recursive Language Models stuff is eating up your dev hours, let me handle it. I’ve been wrestling with WordPress and AI integrations since the early days.
The Bottom Line: Stop Regurgitating Data
The beauty of Recursive Language Models is their laziness. A senior dev knows that the best code is the code you don’t write; a senior AI architect knows that the best tokens are the ones you don’t generate. By moving the heavy lifting into a sandboxed Python REPL and using recursive subagents that pass variables instead of strings, we finally have a way to build agents that can handle millions of tokens without breaking a sweat.
” queries:null},excerpt:{raw:
