Recursive Language Models (RLMs) represent a significant advancement in agentic architectures, offering superior performance on long-context benchmarks by addressing the limitations of existing methods like ReAct and CodeAct. Unlike previous approaches that rely on token-by-token generation or rigid tool calls, RLMs utilize a Read-Eval-Print-Loop (REPL) environment. This framework allows the model to programmatically explore, manipulate, and retrieve context, enabling it to handle tasks with arbitrarily large inputs without being constrained by standard context windows or prone to information loss during generation. Traditional agentic designs struggle with complex, multi-step tasks. Direct generation fails to handle large data sets, while ReAct requires pre-defined tools and forces the model to memorize and regurgitate intermediate results, leading to transmission errors. CodeAct improves flexibility by allowing the model to write and execute its own code, yet it still faces the same memory bottleneck where the model must reconstruct outputs from its short-term memory. Even adding subagents to CodeAct does not fully solve the issue, as the parent agent must still read all sub-agent responses into its context window to synthesize a final answer. RLMs solve this by decoupling context storage from the model's attention mechanism. In an RLM setup, the user's prompt or large dataset is stored in a persistent variable within a Python-like REPL. The model does not load the entire input at once. Instead, it reads specific slices of the data, processes them, and stores intermediate results in variables. For example, to generate a nested dictionary of 150 names across three categories, the model can spawn sub-agents via an llm_query function. These sub-agents execute independently and return their results as Python objects, not text to be memorized. The parent agent can then compose these objects directly into a final variable without ever reading the full contents of every sub-agent's output into its own context. This architecture offers several distinct advantages. First, it enables focused attention. The model intelligently selects which sections of a massive context to load, avoiding the inefficiency of scanning irrelevant data. Second, it supports robust multi-step reasoning. Since variables persist in the REPL runtime, the model can iteratively refine its plan, check its progress via print statements, and correct errors without losing state. Third, it allows for arbitrarily long outputs. Rather than auto-regressing a long text string, the model constructs the answer as a data structure within the code environment, which is then returned as the final result. The efficiency of RLMs extends to cost and speed. By parallelizing sub-agent queries using asynchronous programming, tasks are completed significantly faster than sequential processing. Furthermore, because sub-agents operate within a stable message template, they benefit from KV cache optimization, reducing computational costs. The system effectively separates planning from execution, allowing the root model to orchestrate a strategy while specialized sub-agents handle specific data chunks. This modularity means developers can swap different models for different tasks, optimizing for cost or capability. Implemented in open-source frameworks like fast-rlm, this approach has been tested on massive datasets, including millions of tokens from podcast transcripts, demonstrating that RLMs can manage complexity that overwhelms traditional agents. By treating the LLM as a driver within a persistent programming environment rather than a passive text generator, RLMs offer a scalable, reliable, and cost-effective path forward for general-purpose AI agents.