# RLM: Recursive Language Models for Large Codebases

Shashi Jagtap, Superagentic AI

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/8oyalrfwgjw-rlm-recursive-language-models-large-codebases) · [Video](https://www.youtube.com/watch?v=8oyalrfwgjw)

## Recursive Language Models for Large Codebases

Keep repository context outside the model’s working window, inspect it with Python, and use focused model subqueries to build an answer from evidence.

Familiarity with coding agents, source repositories and basic Python will help with the REPL example.

### When the repository outgrows the working context

[0:08](https://www.youtube.com/watch?v=8oyalrfwgjw&t=8s)

How can a coding agent investigate a large monorepo without losing the context it needs? **[Recursive Language Models](https://arxiv.org/abs/2512.24601)**, or RLMs, provide a context-management pattern that can be incorporated into a coding-agent harness. The paper comes from Alex L. Zhang, Tim Kraska and Omar Khattab; Shashi Jagtap’s walkthrough applies its ideas to source repositories.

The starting problem is familiar: a coding agent works well on a small repository, then becomes less effective as the context grows. In Jagtap’s account, large monorepos make that degradation especially apparent. The agent must retain architecture and relationships across files while filtering out irrelevant material. Having more code available does not automatically give it a useful understanding of the system.

![The problem slide contrasts small repositories, lost architecture and cross-file links, context noise, and codebases as structured systems.](https://ai.engineer/api/talk-essay-media/c17e0a4801b42f9c32bf75f4ff11cbafc5c23bdcf4072de80389646fb08e5d37)

A codebase is a structured system, not a long document.

Existing harnesses manage this problem in several ways:

| Approach | How it manages context |
|---|---|
| Filesystem search | Use tools such as `grep` to find relevant code. |
| Semantic or local search | Retrieve code and curate a selection for the model. |
| Context compression | Replace a long context with a summarized version. |
| Persistent memory | Retain information for the coding agent to use later. |

These approaches determine what the agent finds, what enters its working context and what survives beyond the current interaction.

### Make context something the model can operate on

[2:05](https://www.youtube.com/watch?v=8oyalrfwgjw&t=125s)

**Externalize context management into a programmable execution environment.** That is the central RLM move. The repository remains available as data outside the main model’s context window, and the model writes code to inspect it, select portions of it or compute relevant values. The results of those operations become the material returned to the model.

A dedicated **REPL**—a read–evaluate–print loop—gives the model a place to perform that work. Instead of receiving the entire repository as prompt text, it can investigate the repository and bring selected observations into its working context. Jagtap also proposes this external environment as a possible memory layer for a coding agent.

### Investigate like a lead engineer

[3:10](https://www.youtube.com/watch?v=8oyalrfwgjw&t=190s)

Imagine joining a project as its lead engineer and encountering a huge monorepo. You would begin by inspecting its structure, identifying dependencies and making notes. When something remained unclear, you might ask another engineer or a specialist for help. Reading every line before doing anything useful would be an impractical starting point.

The RLM environment plays the role of that engineer’s notebook. Files, documentation and configuration form the material under investigation; REPL state holds the working notes; scripts perform targeted searches. A call to `llm_query` plays the role of consulting a specialist in another model environment. Its answer returns to the investigation, which eventually produces a clean synthesis. The delegated work can involve one question or several.

![An investigating engineer, focused helper task, and returned note appear beside mappings to repository files, REPL state, Python scripts, and helper queries.](https://ai.engineer/api/talk-essay-media/99c283d3d68aa31a529c8d446d815eb3f8cbf58f8f5706f93cb1e933198b4930)

The engineer’s notebook maps to persistent REPL state, while helper tasks return clean notes.

Translated into an execution loop, the procedure is:

1. **Inspect the external context.** The model writes REPL code that operates on the repository.
2. **Return a bounded observation.** Execution produces selected evidence for the model to consider.
3. **Delegate when needed.** A call to `llm_query` sends a focused question to another model environment and returns its response.
4. **Continue or finish.** The parent investigation uses the returned information, performs further work if needed and terminates with a final result.

The subquery is part of the investigation: its response comes back to the parent loop rather than becoming a separate, disconnected answer.

Repositories make this pattern particularly interesting because their meaning is distributed across structure as well as text. Directories, imports and dependencies encode relationships; tests, images and configuration accompany the source. **A codebase is structured data**, so the investigation must reason about how its parts fit together, not merely locate passages in a long document.

### Choose an implementation of the pattern

[6:09](https://www.youtube.com/watch?v=8oyalrfwgjw&t=369s)

[`rlm-code`](https://github.com/SuperagenticAI/rlm-code) is Superagentic AI’s open-source research playground for experimenting with these ideas. It supplies a harness, documentation and source code, but it is one implementation of RLM rather than the definition of RLM itself.

The paper’s authors provide [RLM](https://github.com/alexzhang13/rlm) and [RLM Minimal](https://github.com/alexzhang13/rlm-minimal). Another implementation is [`dspy.RLM`](https://dspy.ai/api/modules/RLM/), within DSPy. These are separate implementations of the same general pattern; using RLM does not require adopting DSPy or any particular library. Jagtap uses `rlm-code` as an independent reference harness to expose the mechanism during the demonstration.

In `rlm-code`’s RLM mode, the stated core remains REPL execution and recursive model calls. Around that core, Jagtap describes several implementation choices:

- **Model backend:** Run with a local model or a cloud model.
- **Observability:** Connect the investigation to an observability framework.
- **Agent framework:** Apply the pattern through a framework such as Pydantic AI or Google ADK.

A companion source repository provides a way to try the concepts. The demonstration’s purpose is to make the path visible: where context is created, what Python the model writes, what it sends to `llm_query` and how those operations produce the final answer.

### Run the loop over rlm-code’s own source

[9:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=583s)

The CLI demonstration uses the checked-out `rlm-code` source as its target repository. The accompanying README offers instructions for local-model execution, but the recorded run uses **Gemini**. Jagtap starts the script, shows the **Docker sandbox** container starting and then returns to the completed execution.

The first visible step is model-written Python REPL code that builds evidence from the repository. A small probe for investigating the subquery mechanism, for example, can search from the repository root and return short excerpts around `llm_query`:

```python
from pathlib import Path

root = Path.cwd()
excerpts = []

for path in sorted(root.rglob("*.py")):
    lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
    for line_no, line in enumerate(lines):
        if "llm_query" in line:
            start = max(0, line_no - 2)
            stop = min(len(lines), line_no + 3)
            excerpt = "\n".join(lines[start:stop])
            excerpts.append(
                f"{path.relative_to(root)}:{line_no + 1}\n{excerpt[:1200]}"
            )
            break
    if len(excerpts) == 6:
        break

print("\n\n".join(excerpts))
```

The files remain on disk. The observation consists of selected excerpts with file locations, and the output limits keep that inspection from dumping the repository into the model’s context.

The recorded run then sends a prompt through `llm_query`, receives the response and produces a final answer. This exposes the transition from programmatic evidence collection to a model subquery and then to synthesis.

Jagtap describes this run as making two tool calls. The terminal also displays token usage.

**Editor’s note:** [Jagtap’s companion report](https://shashikantjagtap.net/superagentic-ai-speaks-on-rlm-at-the-ai-engineer-worlds-fair-2026/) counts model requests instead: a root-planning call and an `llm_query` subcall. The distinction matters when interpreting the count; this demonstration does not establish a general cost or performance result.

![Terminal showing a FINAL answer, numbered evidence rows, and a USAGE block with call and token counts; presenter inset at lower right.](https://ai.engineer/api/talk-essay-media/3e309310095ec1275be0b30d0f7fac71b61c15177876ec3a9100ac51473a72c9)

Final CLI output with source evidence and usage totals.

The run leaves records that can be inspected afterward. Jagtap opens the stored runs and sessions, showing that the final answer is accompanied by a trace of the work that produced it. He presents these records as material that can be connected to an observability platform.

### Bound the run and inspect its trajectory

[12:08](https://www.youtube.com/watch?v=8oyalrfwgjw&t=728s)

The experimental terminal interface exposes the same mechanism through a coding-agent-style workflow:

1. **Connect a model.** Use `connect` to select the provider and model. The demonstration again uses Gemini.
2. **Check the environment.** Run `doctor`. It reports warnings involving Deep Agents, ADK and other framework integrations, which Jagtap identifies as irrelevant to this particular demonstration.
3. **Submit a bounded investigation.** Send the question with a spending budget. Maximum steps and recursion depth provide additional controls over the run.

These controls make the amount of investigation an explicit part of the request.

After execution, the research-lab view shows completion and a reward display. The more revealing view is the **trajectory**, which exposes the REPL operations, generated code and final output. An events view records when execution started and ended. Together, these views let the user inspect the sequence of work rather than judge the system only by its final response.

Returning to the slides, Jagtap connects the visible stages: context is loaded, Python extracts snippets, `llm_query` supplies a model response and the investigation produces its result. The traces are available in **JSONL** for use in an observability workflow. The answer draws on evidence from multiple files, making the recorded path through that evidence useful alongside the answer itself.

### Design the harness around the investigation

[15:09](https://www.youtube.com/watch?v=8oyalrfwgjw&t=909s)

The immediate applications are investigations of large or unfamiliar repositories:

- **Root-cause analysis:** Gather relevant code and relationships to investigate why a system behaves as it does.
- **Repository onboarding:** Explore an unfamiliar codebase and build an understanding of its structure.

These are starting points for applying the pattern to a concrete engineering task.

A custom harness should capture the **whole trajectory**: planning, generated code, observations, subcalls, budget and final output. That record makes it possible to inspect how the investigation proceeded, what evidence it collected and where it spent its resources. The harness can be adapted to the task while preserving visibility into those stages.

### Where RLM overlaps with other agent workflows

[15:51](https://www.youtube.com/watch?v=8oyalrfwgjw&t=951s)

The closing discussion turns to related behavior in proprietary agent systems. Jagtap reports seeing posts about managed agents and dynamic workflows using RLM concepts. He also describes observing **Codex** write Python in a REPL to curate context, and associates **Claude** and Gemini managed-agent workflows with similar ideas. These are his observations and comparisons, rather than established descriptions of those products’ internal architectures.

The dynamic-workflow example extends the comparison: an agent receives a task, spawns other agents with separate sandboxes and combines their results. That arrangement resembles the consultation-and-return structure of the earlier engineer analogy.

Jagtap suggests that software factories may also use RLM ideas, while explicitly leaving that adoption uncertain. He then reports acknowledgments on X by Anthropic engineers about using RLM concepts.

**Editor’s note:** The [original RLM paper](https://arxiv.org/html/2512.24601v1) distinguishes ordinary code execution from externalizing context and making programmatic model subqueries. Python execution and separate sandboxes can support that pattern, but do not by themselves establish that a product implements RLM or derives from the research.

![Ecosystem direction slide with Managed Agents, Dynamic Workflows, Software Factories, and RLM Distinction above Codex, Claude Code, Gemini, and a question mark.](https://ai.engineer/api/talk-essay-media/14d61820122bb89dde9660139e51de92b498d219c189dfdaaec3a1a0c564e3ac)

The ecosystem slide lists agent workflows and leaves “RLM Distinction” as a question.

## Resources

- [Recursive Language Models — original paper](https://arxiv.org/html/2512.24601v1) — Original formulation of external context, programmable inspection and recursive subqueries, including experimental limitations.
- [RLM Code](https://github.com/SuperagenticAI/rlm-code) — The independent research harness demonstrated in the talk. Its current README also contains later features.
- [RLM — authors’ implementation](https://github.com/alexzhang13/rlm) — Authors’ implementation with configurable model backends and execution environments; review isolation settings before running.
- [RLM Minimal](https://github.com/alexzhang13/rlm-minimal) — Compact implementation for studying the REPL and depth-one subquery mechanism.
- [DSPy RLM](https://dspy.ai/api/modules/RLM/) — Live documentation for the implementation named in the talk. Current API details are not a historical snapshot.
- [Jagtap’s companion report](https://shashikantjagtap.net/superagentic-ai-speaks-on-rlm-at-the-ai-engineer-worlds-fair-2026/) — Speaker’s account of the demonstration, with links to the original slides and demo repository.
- [Maintained conference demo](https://github.com/SuperagenticAI/rlm-code/blob/main/examples/aie_world_fair_2026/README.md) — Instructions for trying the conference probe against current APIs, explicitly distinguished from the original event snapshot.

## Slides

### RLM: Recursive Language Models for Large Codebases

Shashi Jagtap introduces a coding-agent harness for large codebases built around the RLM control loop, drawing on the MIT paper’s approach to long-context inference.

[0:05](https://www.youtube.com/watch?v=8oyalrfwgjw&t=5s) [Title slide introducing an RLM-inspired coding-agent harness for large codebases.](https://assets.ai.engineer/sites/aiecode2025/sha256/082a3edfeb024e8166671e2d12b4b3d5c5eedd1bd8c2bf1703bf0669acd06887.webp)

AI ENGINEER WORLD'S FAIR 2026
Online Track

RLM: Recursive Language Models for Large Codebases

A coding-agent harness pattern, inspired by the MIT RLM paper.

MIT RLM paper: arXiv:2512.24601

Shashi Jagtap
Founder, Superagentic AI

MIT RLM PAPER
Recursive Language Models
RLMs use a programmable environment for long-context inference.
arXiv:2512.24601

MIT RESEARCH
The RLM concept
Use the RLM control loop as a coding-agent harness pattern for large repository investigatio[illegible]

Interface text:
localhost
RLM: Coding-Agent Harness Pattern for Large Codebases
→ next · ← back · F fullscreen

### The problem

Large repositories make architecture, ownership, and cross-file links harder to track. Larger context windows add noise, while codebases require investigation as structured systems.

[0:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=43s) [Four cards contrast small repositories, large repositories, added context, and the structured nature of codebases.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ab2998e048eeb13cb96da4acb9847c26149af8918a8b8f22fcbece109b74a05.webp)

The problem

Large repositories require stateful, structured investigation.

SMALL REPO
One file, one test, one function. Agents handle this well.

LARGE REPO
Lost architecture, ownership, and cross-file links.

MORE CONTEXT
Bigger windows add noise. Tool output floods the chat.

REAL PROBLEM
A codebase is a structured system, not a long document.

Interface text:
localhost
RLM: Coding-Agent Harness Pattern for Large Codebases

### How people tackle it today

Coding agents can search files, retrieve relevant code, compress context, or persist working state. Each helps manage a large repository, but retrieval can miss structure and larger contexts can add noise.

[1:14](https://www.youtube.com/watch?v=8oyalrfwgjw&t=74s) [Four cards describe filesystem tools, semantic retrieval, long context, and agent memory.](https://assets.ai.engineer/sites/aiecode2025/sha256/80abc36871c8777d897822ccc902dad7f5b2ae7c727e2df18b4c478e8db7ebf3.webp)

How people tackle it today
Search, retrieval, and longer context all help.

FILESYSTEM TOOLS
Search the repo directly
grep, file readers, virtual FS. Good when paths are known.

SEMANTIC RETRIEVAL
Find likely-relevant code
Embeddings narrow the haystack, but can miss structure.

LONG CONTEXT
Load or compress evidence
Bigger windows help, but detail competes with noise.

AGENT MEMORY
Persist working state
Scratchpads and task state avoid rereading every token.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### The RLM Idea

RLM moves context management into a separate programmable environment that the model can operate on.

[2:03](https://www.youtube.com/watch?v=8oyalrfwgjw&t=123s) [Section divider introducing the idea of moving context into a programmable execution environment.](https://assets.ai.engineer/sites/aiecode2025/sha256/0a25286ce9dc3db46ba3ce23aa9ed78efec4a34f95d51920f3ded4b1fa1b2f20.webp)

01
The RLM Idea
From the MIT RLM paper: move context into a programmable execution environment.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### The thesis

RLM treats the repository as data: the model writes code to inspect and slice it, while focused subquestions return clean values for the main context.

[2:12](https://www.youtube.com/watch?v=8oyalrfwgjw&t=132s) [The slide states that RLM externalizes context management into a programmable environment and lists three supporting steps.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c425b5ba441370e6f79b1f60b10229de2c88fb4704f0b544c67aaa44244ccfd.webp)

THE THESIS

RLM externalizes context management into a programmable execution environment.

MIT RLM paper: arXiv:2512.24601

1. The repository is treated as data the model can operate on.
2. The model writes code to inspect, slice, and compute.
3. Focused subquestions return clean values.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### The analogy

An engineer keeps notes while investigating a codebase and asks a helper focused questions. In the RLM analogy, the notebook is persistent REPL state, and the helper returns a clean value for synthesis.

[3:09](https://www.youtube.com/watch?v=8oyalrfwgjw&t=189s) [An engineer with a notebook delegates a focused helper task and receives a clean note; a table maps the analogy to RLM components.](https://assets.ai.engineer/sites/aiecode2025/sha256/4fa30f4e635a4f86e79dfcf131e418c9a2e9becbd26e57db26cf724d9fd64f11.webp)

The analogy
A senior engineer with a notebook.

Engineer doing the investigation
keeps notes, evidence, and open questions

Focused helper task
inspect this evidence

Clean note returned
added back to the notebook

Large project → Files, docs, tests, configs
Notebook → Persistent REPL state
Investigation scripts → Model-written Python
Focused helper question → llm_query(...)
Returned note → A clean value for synthesis

Recursion = the parent REPL calling llm_query(...) and getting a clean value back.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### The loop

The root model writes REPL code to inspect the repository and receive bounded observations. When it needs more information, it can call llm_query, use the returned value, and continue until it produces a final result.

[4:54](https://www.youtube.com/watch?v=8oyalrfwgjw&t=294s) [Diagram showing repository context, model-written REPL code, recursive subcalls, returned results, and finalization.](https://assets.ai.engineer/sites/aiecode2025/sha256/98351e0e11ab8397b07a28cb6e29a6924b7eea100792511e39f1e85a949d2ed7.webp)

The loop
How the harness actually runs.

Repo context
context

Root model
writes repl code

Python REPL
bounded observation

Recursive subcall
llm_query(...)

Clean result
value returns

Finish
FINAL / FINAL_VAR

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### Why codebases

A codebase gives the model more than text: directories map the repository, imports reveal execution paths, and tests expose intended behavior. The inspection flow extracts evidence, queries a model, and returns a final result.

[5:32](https://www.youtube.com/watch?v=8oyalrfwgjw&t=332s) [Lists repository structures and illustrates how files, tests, and documentation support model inspection.](https://assets.ai.engineer/sites/aiecode2025/sha256/993c38a89a66a328ac9961aa9eb4a690ab5a972626ad35f92bcf9a193dc118e4.webp)

Why codebases
Repos are structured and executable.

1 Files and directories give the model a map.
2 Imports and symbols reveal execution paths.
3 Tests and fixtures expose intended behavior.
4 Configs and docs explain runtime assumptions.

REPOSITORY AS STRUCTURED DATA
runner.py  orchestration
environment.py  REPL state
termination.py  FINAL / FINAL_VAR
tests/  behavior checks
README.md  usage contract

MODEL-WRITTEN INSPECTION
extract evidence → llm_query → FINAL

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### RLM Code

Superagentic AI’s RLM Code is an independent experimental reference implementation for demonstrating the RLM pattern. The slide points to its landing page, docs, and GitHub.

[6:06](https://www.youtube.com/watch?v=8oyalrfwgjw&t=366s) [Section slide introducing RLM Code as an experimental reference implementation.](https://assets.ai.engineer/sites/aiecode2025/sha256/33528dff6f5ffe5a51849fcacd3a3fc87bd851a270e1f45a537ebd6d2c2d46ee.webp)

02
RLM Code

An independent experimental reference implementation used to demonstrate the pattern.

Landing page
Docs
GitHub

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### RLM Code landing page

Superagentic AI presents RLM Code as an open-source research playground for running and comparing RLM workflows, with documentation and a GitHub repository.

[6:24](https://www.youtube.com/watch?v=8oyalrfwgjw&t=384s) [RLM Code landing page describes a research playground for recursive language models.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6c628e687528fa22ff0c11676827b90aebca6eef7f5e1f507a63ed39e5a7e8e.webp)

RESEARCH-FIRST EVALUATION OS

RLM Code
Research Playground for Recursive Language Models

Run real RLM workflows, benchmark them, replay every step, and compare results under controlled budgets and secure sandboxes.

Open source under Apache-2.0. Explore the project on GitHub.

Start with Docs
View GitHub

Apache-2.0
PyPI Package
Research-first

What is included
Preferred stack
Code Mode support
Watch demo
Quick workflow
Security
FAQ

Embedded screenshot:
RLM Code
Research Playground & Evaluation OS for RLM Agentic Systems
RLM  Files  Details  Shell  Research Lab  One Screen: ON  Quit
RLM Research Lab
Dashboard  Trajectory  Benchmarks  Replay  Events
Run Dashboard
Welcome to the Research Lab
Quick start:
[illegible]
Available presets: [illegible]

Interface text:
super-agentic.ai
RLM: The Coding Agent Harness Secret for Massive Codebases
RLM Code | Research Playground for Recursive Language Models | Superagentic AI
SuperagenticAI
Products  Solutions  OSS  Research  Resources  Company

### Implementation options

RLM is a pattern that can be implemented in different ways: use the official repositories or DSPy.RLM, build a project-specific harness, or try RLM Code for a live demo.

[6:44](https://www.youtube.com/watch?v=8oyalrfwgjw&t=404s) [Four options: official repositories, DSPy.RLM, a project-specific harness, and RLM Code.](https://assets.ai.engineer/sites/aiecode2025/sha256/afab2b95cc7f627c5e9d95d07eb5fa127784baf5105a5d61523a81d3a695bd20.webp)

Implementation options
The RLM pattern is implementation-agnostic.

01
MIT paper & official repos
Reference framing, examples, rlm-minimal.

02
DSPy.RLM
Sandboxed Python REPL + recursive sub-LLM calls.

03
Project-specific harness
Build the core idea yourself.

04
RLM Code
Independent harness for a live demo.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost
RLM: The Coding Agent Harness Secret for Ma...
RLM Code | Research Playground for Recursive...
RLM Code
SuperagenticAI/rlm-code: The Research Playgr...

### Source boundary

The MIT paper supplies the concept, RLM Code implements the loop, and the live demo shows the code running through recursion to a final answer.

[8:44](https://www.youtube.com/watch?v=8oyalrfwgjw&t=524s) [Three rows distinguish the MIT RLM paper, RLM Code source, and live demo output.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c830251c9508cd5ad9abd9949fbcbefbc1a7a2703ed568ba2fb5cf480101c38.webp)

Source boundary
Separate concept, implementation, and observation.

MIT RLM paper
The concept: executable env, recursion, finalization.

RLM Code source
The implementation: context vars, REPL, llm_query, FINAL.

Live demo output
The observation: code runs, recursion fires, final answer.

RLM: Coding-Agent Harness Pattern for Large Codebases

Interface text:
localhost

### The loop, in code

The REPL receives the repository as context and registers llm_query for recursive model calls. execute_action runs model-written code; FINAL and FINAL_VAR end the run with an answer.

[9:07](https://www.youtube.com/watch?v=8oyalrfwgjw&t=547s) [Code examples show context loading, recursive model calls, REPL execution, and finalization.](https://assets.ai.engineer/sites/aiecode2025/sha256/90b13c55d86d96c21d0617e03f578982b06fb5cfc98bf1e8b472aabb96bcab2d.webp)

The loop, in code
Each part of the RLM loop maps to a specific place in the RLM Code source.

pure_rlm_environment.py
self._namespace["context"] = context
the repo is loaded into the REPL as the context variable
self._namespace["llm_query"] = llm_query_fn
llm_query is registered, so REPL code can call the model recursively
def execute_action(...)
the model-written REPL code runs here

termination.py
def FINAL_VAR(variable_name[illegible]
FINAL / FINAL_VAR end the run with a clean answer

Interface text:
localhost
RLM: Coding-Agent Harness Pattern for Large Codebases

### Probe script

The probe imports RLM Code components and patches request handling for slow local servers, setting defaults for temperature and output tokens. The presenter plans to run it with Gemini.

[10:16](https://www.youtube.com/watch?v=8oyalrfwgjw&t=616s) [Editor displaying the probe script imports and request timeout patch.](https://assets.ai.engineer/sites/aiecode2025/sha256/9644eef430e5e87efde8cff4bb8c9600627b92bd5351c28de495d386cff433f2.webp)

scripts/rlm_probe.py

from __future__ import annotations

import json
import os
import sys
from pathlib import Path
from types import SimpleNamespace
from typing import Any

import requests

from rlm_code.core.config import ConfigManager
from rlm_code.models.llm_connector import LLMConnector
from rlm_code.rlm.pure_rlm_environment import PureRLMConfig, PureRLMEnvironment
from rlm_code.rlm.docker_interpreter import DockerPersistentInterpreter


def patch_requests_for_demo(timeout_seconds: int, max_tokens: int) -> None:
    """Let slow local OpenAI-compatible servers exceed RLM Code's default timeout."""
    original_post = requests.post

    def post_with_demo_timeout(*args: Any, **kwargs: Any) -> requests.Response:
        if kwargs.get("timeout") == 120:
            kwargs["timeout"] = timeout_seconds
        payload = kwargs.get("json")
        if isinstance(payload, dict) and "messages" in payload:
            payload.setdefault("temperature", 0.2)
            payload.setdefault("max_tokens", max_tokens)
        return original_post(*args, **kwargs)

Interface text:
rlm-codebase-aie-wf26-talk
main
Sign In
README.md
rlm_probe.py
.github/workflows
.venv
demo_targets/rlm-code
node_modules
scripts
src
.gitignore
index.html
package.json
package-lock.json
prompts.md
pyproject.toml
README.md
tsconfig.json
use-cases.md
uv.lock
vite.config.ts
1:1
Python 3.12.11

### Model response and evidence search

In the first step of the probe, the model writes REPL code to list context files and their lengths, then defines search terms for building an evidence list.

[11:01](https://www.youtube.com/watch?v=8oyalrfwgjw&t=661s) [Terminal showing model-generated code that lists context files and defines evidence search terms.](https://assets.ai.engineer/sites/aiecode2025/sha256/d6028af62be6a758ecfabc2908332c3ec80d9a4be04dd8331dd5149a7bc1ec0c.webp)

env RLM_PROBE_PROVIDER=gemini \
    RLM_PROBE_MODEL=gemini-2.5-flash \
    RLM_PROBE_STEPS=3 \
    RLM_PROBE_CONTEXT=mini \
    RLM_PROBE_MAX_OUTPUT_CHARS=1600 \
    RLM_PROBE_MAX_TOKENS=2048 \
    RLM_PROBE_MAX_LLM_CALLS=12 \
    uv run python scripts/rlm_probe.py

connected=gemini/gemini-2.5-flash
sandbox=docker

STEP 1 MODEL RESPONSE
```repl
import re

# Step 1: Print context file names and lengths.
print("Context files and their lengths:")
for filename, content_str in context.items():
    print(f"- {filename}: {len(content_str)} characters")

# Step 2: Build evidence_list
evidence_list = []
search_terms = [
    "self._namespace[\"context\"]",
    "self._namespace[\"llm_query\"]",
    "def execute_action",
    "def FINAL_VAR"
]

Interface text:
Search sessions, agents, files...
shashi at Shashis-MacBook-Airbook Air: rlm-codebase-aie-wf26-talk 3.13.2 24.14.0 (main)
(base) 0 (0.193s) < 20:51:17

### Probe execution and final answer

The probe passes collected code evidence to llm_query, then combines the model’s summary with the evidence rows in its final answer. The run reports two calls and their token usage.

[11:19](https://www.youtube.com/watch?v=8oyalrfwgjw&t=679s) [Terminal showing final-answer construction and a partially visible successful execution observation.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f92ab67cb6b984469fee878a2307f5d49fbae38d7807e1959cd0531f2a60e57.webp)

env RLM_PROBE_PROVIDER=gemini \
    RLM_PROBE_MODEL=gemini-2.5-flash \
    RLM_PROBE_STEPS=3 \
    RLM_PROBE_CONTEXT=mini \
    RLM_PROBE_MAX_OUTPUT_CHARS=1600 \
    RLM_PROBE_MAX_TOKENS=2048 \
    RLM_PROBE_MAX_LLM_CALLS=12 \
    uv run python scripts/rlm_probe.py

"Based on the following code snippets, identify the core mechanics of "
"Recursive Language Models directly shown. "
"Respond with one technical sentence, no Markdown, naming only the mechanics directly shown by the evidence.\n\n"
"Evidence:\n" + evidence_text
)
recursive_summary = llm_query(llm_query_prompt)

# Step 4: Assign final_answer
final_answer = f"{recursive_summary}\n\nEvidence Rows:\n" + "\n".join(evidence_list)

# Step 5: Finish with FINAL(final_answer)
FINAL(final_answer)
```

Docker pure_rlm backend needs host networking for external calls; ignoring network_enabled=false for interpreter session.

OBSERVATION
{
  "success": true,
  "stdout": "Context files and their lengths:\n- rlm_code/rlm/pure_rlm_environment.py: 2258 char[illegible]
[illegible]/rlm/runner.py: 450 characters\n- rlm_code/rlm/termination.py: 902 characters\n- rlm_code/tests/[illegible]

Interface text:
Search sessions, agents, files...
shashi at Shashis-MacBook-Airbook Air: rlm-codebase-aie-wf26-talk 3.13.2 24.14.0 (main)
(base) 0 (0.193s) < 20:51:17

[11:30](https://www.youtube.com/watch?v=8oyalrfwgjw&t=690s) [Terminal shows a probe’s final answer and supporting code evidence.](https://assets.ai.engineer/sites/aiecode2025/sha256/08f064b4f3c6998aec0a01714f9372a4624d58734bf329f402dca7dfcf5a80be.webp)

env RLM_PROBE_PROVIDER=gemini \
    RLM_PROBE_MODEL=gemini-2.5-flash \
    RLM_PROBE_STEPS=3 \
    RLM_PROBE_CONTEXT=mini \
    RLM_PROBE_MAX_OUTPUT_CHARS=1600 \
    RLM_PROBE_MAX_TOKENS=2048 \
    RLM_PROBE_MAX_LLM_CALLS=12 \
    uv run python scripts/rlm_probe.py

]
}

FINAL
The core mechanics shown are contextual state management, language model query specification, and defined action execution.

Evidence Rows:
600: self._namespace["context"] = context
709: self._namespace["llm_query"] = llm_query
1255: def execute_action(
57: def FINAL_VAR(variable_name: str) -> NoReturn:

USAGE
{
  "totals": {
    "total_calls": 2,
    "prompt_tokens": 2730,
    "completion_tokens": 462
  },
  "by_model": {

Interface text:
Search sessions, agents, files...
shashi at Shashis-MacBook-Airbook Air: rlm-codebase-aie-wf26-talk 3.13.2 24.14.0 (main)
(base) 0 (0.193s) < 20:51:17

### Probe usage

The Gemini 2.5 Flash probe reports two model calls, using 2,730 prompt tokens and 462 completion tokens. It also records usage for the last call separately.

[11:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=703s) [Terminal shows model usage, including two calls and token counts.](https://assets.ai.engineer/sites/aiecode2025/sha256/255ac26ae736f2f54d2ba588471018f4998ddfe842c80b7b5ef31531c16ba314.webp)

env RLM_PROBE_PROVIDER=gemini \
    RLM_PROBE_MODEL=gemini-2.5-flash \
    RLM_PROBE_STEPS=3 \
    RLM_PROBE_CONTEXT=mini \
    RLM_PROBE_MAX_OUTPUT_CHARS=1600 \
    RLM_PROBE_MAX_TOKENS=2048 \
    RLM_PROBE_MAX_LLM_CALLS=12 \
    uv run python scripts/rlm_probe.py

"prompt_tokens": 2730,
"completion_tokens": 462
},
"by_model": {
  "gemini/gemini-2.5-flash": {
    "provider": "gemini",
    "model": "gemini-2.5-flash",
    "calls": 2,
    "prompt_tokens": 2730,
    "completion_tokens": 462
  }
},
"last_call": {
  "timestamp": "2026-06-28T19:52:14.126566+00:00",
  "provider": "gemini",
  "model": "gemini[illegible]2.5-flash",
  "model_id": "gemi[illegible]/gemini-2.5-flash",
  "prompt_tokens": 112,
  "completion_tokens": 19
}
}

Interface text:
Search sessions, agents, files...
shashi at Shashis-MacBook-Airbook Air: rlm-codebase-aie-wf26-talk 3.13.2 24.14.0 (main)
(base) 0 (0.193s) < 20:51:17

## Full transcript

[0:00](https://www.youtube.com/watch?v=8oyalrfwgjw&t=0s) Hello, and welcome to this online track talk for the AI Engineer World’s Fair 2026.

[0:08](https://www.youtube.com/watch?v=8oyalrfwgjw&t=8s) Today, we're going to explore the concept of RLM, also known as Recursive Language Models, and how we can use those concepts for larger code bases. My name is Shashi.

[0:21](https://www.youtube.com/watch?v=8oyalrfwgjw&t=21s) I'm a founder of Superagentic AI. First of all, let's be clear that RLM paper has been published by MIT & Friends. As you can see, there's a full paper.

[0:32](https://www.youtube.com/watch?v=8oyalrfwgjw&t=32s) You can read about it. But the purpose of this talk is how you can use the concepts of RLM, and you can use into your own workflow to implement your own harnesses.

[0:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=43s) So first of all, what's the problem? If you're using the coding agents for smaller repos or on monorepos, they works exceptionally well. But if you have ever tried it with the monorepos with the large context, you know there's a context problem.

[0:58](https://www.youtube.com/watch?v=8oyalrfwgjw&t=58s) As the context grows, the performance degrade. And if you're working with the monorepos, this problem get worse. In this talk, we will see we selected the code base and the concept of RLMs are relevant for the larger code bases.

[1:15](https://www.youtube.com/watch?v=8oyalrfwgjw&t=75s) If you use the coding agents, then you probably saw that there are different approaches that other coding-agent harnesses have been taken to solve this problem. Most common approach is searching using the tools like grep.

[1:28](https://www.youtube.com/watch?v=8oyalrfwgjw&t=88s) So basically, there's a file system and the coding-agent harnesses search using these tools.

[1:34](https://www.youtube.com/watch?v=8oyalrfwgjw&t=94s) The second approach, you've probably seen that the semantic search or the local search. So idea here is basically you can search through the code and curate the context. Another approach is the long context get compressed, and you can use the summarized version of the context.

[1:54](https://www.youtube.com/watch?v=8oyalrfwgjw&t=114s) And there are some memory solutions available in the market as well that you can use to persist the memory for the coding agent.

[2:05](https://www.youtube.com/watch?v=8oyalrfwgjw&t=125s) First of all, let's explore the RLM idea. The core thesis of the RLM is you need to externalize the context management into programmable execution environment, meaning you should have a separate dedicated environment, so that model can operate on that.

[2:23](https://www.youtube.com/watch?v=8oyalrfwgjw&t=143s) In this case, for example, your whole repository is treated as a data that model can operate on. Then model can write the code to inspect, slice, and compute the relevant chunks or values you can then feed into the main context window.

[2:42](https://www.youtube.com/watch?v=8oyalrfwgjw&t=162s) So basically, rather than putting everything into the model's context, create a separate dedicated environment, give them a coding agent or REPL, and then model write the code to curate the context that can be used into the main.

[2:59](https://www.youtube.com/watch?v=8oyalrfwgjw&t=179s) So it's another context management technique proved to be very effective. Could be also be used as a memory layer for your coding agents.

[3:10](https://www.youtube.com/watch?v=8oyalrfwgjw&t=190s) Let me summarize this, giving you a simple analogy. Imagine you are a lead software engineer and assigned to the new project with a huge code base.

[3:22](https://www.youtube.com/watch?v=8oyalrfwgjw&t=202s) Imagine that's monorepo. How does that lead engineer deals with the code? So rather than reading each line of code line by line, engineer probably inspect the code base, make some notes, see what are the project's dependencies, how it is structured.

[3:42](https://www.youtube.com/watch?v=8oyalrfwgjw&t=222s) If it's something else, uh, is not understood by the engineer, engineer probably ask to another engineer or expert to get some ideas. And the same concepts applied in RLM.

[3:55](https://www.youtube.com/watch?v=8oyalrfwgjw&t=235s) So large project like the files and docs and texts and configs because repository has a lot of things. And the programmable REPL, it's kind of a notebook that engineer makes a note about the code base that can be used.

[4:08](https://www.youtube.com/watch?v=8oyalrfwgjw&t=248s) Researching, he may be using other techniques, or maybe he's writing some script to search something from the repo.

[4:16](https://www.youtube.com/watch?v=8oyalrfwgjw&t=256s) And then if he's stuck, then he ask another engineer or specialist where it come to the LLM query. An LLM query is basically asking another model environment to get an answer from.

[4:31](https://www.youtube.com/watch?v=8oyalrfwgjw&t=271s) And once they get answer, then the loop continues. And at the end, it returns the clean note synthesis.

[4:40](https://www.youtube.com/watch?v=8oyalrfwgjw&t=280s) So the recursion part here is engineer ask another specialist using LLM query. That can be

[4:48](https://www.youtube.com/watch?v=8oyalrfwgjw&t=288s) one question or that can be number of questions. So this is where the recursion comes in picture.

[4:54](https://www.youtube.com/watch?v=8oyalrfwgjw&t=294s) Loop is basically you have repo, uh, as your context, and then the model writes the REPL code to get some relevant context

[5:06](https://www.youtube.com/watch?v=8oyalrfwgjw&t=306s) that returns the bounded observation. And if we-- if loop needs more information, it passes through the LLM query, where it asks another language model or another system to get the response,

[5:21](https://www.youtube.com/watch?v=8oyalrfwgjw&t=321s) return the value, and continue the loop. And the loop get terminated until we get a final results.

[5:31](https://www.youtube.com/watch?v=8oyalrfwgjw&t=331s) Why are we talking about the code base and not the big context in terms of like, uh, other things, for example, books or dictionaries? Code base is different. It has directories, it has test, it has some imports, it has dependencies, it has tests, it has pictures, it has configuration files.

[5:50](https://www.youtube.com/watch?v=8oyalrfwgjw&t=350s) So the code base is not only just, um, the text, it is a structured data. And the model need to understand and reason over the text. That's why I chose this scenario to use the code bases to prove these concepts of RLM.

[6:09](https://www.youtube.com/watch?v=8oyalrfwgjw&t=369s) Now let's switch the gear and talk about our own library that we created at Superagentic AI called rlm-code. You can see rlm-code's landing page here,

[6:22](https://www.youtube.com/watch?v=8oyalrfwgjw&t=382s) where this is just a research playground where you can implement the concepts of RLM.

[6:29](https://www.youtube.com/watch?v=8oyalrfwgjw&t=389s) We have, um, documentation that you can take a look, and there's a-- the GitHub repository. It is completely open source project that you can use it

[6:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=403s) and play with it. RLM itself is a concept

[6:50](https://www.youtube.com/watch?v=8oyalrfwgjw&t=410s) and a pattern, and you can implement that concept and pattern in your own way. There are official authors also wrote some implementation in their GitHub repos. It's called RLM and RLM Minim- Minimal.

[7:07](https://www.youtube.com/watch?v=8oyalrfwgjw&t=427s) You can refer that. Implementation of RLM in DSPy.RLM. So Omar is author of RLM, and he is also author of another popular framework called DSPy. So DSPy got RLM implementation inside it.

[7:26](https://www.youtube.com/watch?v=8oyalrfwgjw&t=446s) However, you should treat they are completely different. So RLM is a pattern, and you can implement in your own ways. You can find there are various other people implemented RLM in their own way, and

[7:41](https://www.youtube.com/watch?v=8oyalrfwgjw&t=461s) in the similar way, we implemented rlm-code as our own independent harness that we will be using in this live demo.

[7:50](https://www.youtube.com/watch?v=8oyalrfwgjw&t=470s) rlm-code is just a reference implementation to demonstrate how the RLM concepts works under the hood.

[7:59](https://www.youtube.com/watch?v=8oyalrfwgjw&t=479s) So we have implemented something called RLM mode. We are using RLM as it is. We are not adding anything on top of RLM's ideas and RLM's paper. We are using the same concept of recursive calls, REPL execution.

[8:14](https://www.youtube.com/watch?v=8oyalrfwgjw&t=494s) However, you can run it with a local model, you can run with-- run it with cloud-based model, you can plug into any observability framework of your choice, and that gives you, like, a lot of flexibility around RLM.

[8:31](https://www.youtube.com/watch?v=8oyalrfwgjw&t=511s) You can also plug it into the framework of your choice. For example, you can use Pydantic AI or

[8:39](https://www.youtube.com/watch?v=8oyalrfwgjw&t=519s) Google ADK or something similar framework and implement ideas of RLM over there. In order to demonstrate this, we have created a source code repository where you can try this concept by yourself using MIT's RLM paper and rlm-code.

[8:57](https://www.youtube.com/watch?v=8oyalrfwgjw&t=537s) And we will see how these things works in a, in a practice.

[9:03](https://www.youtube.com/watch?v=8oyalrfwgjw&t=543s) So basically, we will show you the loop. This, you will understand this once you-- once we see this live demo and what all these files are doing, where, where is the context is being created, where the Python REPL has written a code, and where it is passed to the llm_query, and how we get the final results.

[9:27](https://www.youtube.com/watch?v=8oyalrfwgjw&t=567s) So that will be covered as part of the live demo. So we can cover this everything here. So in nutshell, how it looks like is basically it creates the REPL, and then observation, and the final recursive language output.

[9:43](https://www.youtube.com/watch?v=8oyalrfwgjw&t=583s) So let me jump into the live demo now. Okay, let's do the live demo of these concepts of RLM and rlm-code and how it works in a, the larger codebases.

[9:55](https://www.youtube.com/watch?v=8oyalrfwgjw&t=595s) So I have a code repositories here I have checked out, and let's open it into the editor so that we can see what's inside it. So as you can see, there's a demo target, which is, um, we are using rlm-code source as a, as a demo here.

[10:15](https://www.youtube.com/watch?v=8oyalrfwgjw&t=615s) And then we have some instructions that you can follow along, um, yourself. So basically,

[10:23](https://www.youtube.com/watch?v=8oyalrfwgjw&t=623s) you have a README file that you can use to use with your local model or... So we are going to use with the Gemini. So we will try this script and see what happen.

[10:37](https://www.youtube.com/watch?v=8oyalrfwgjw&t=637s) So right now, you can see we're using the Docker as a sandbox. If you see,

[10:46](https://www.youtube.com/watch?v=8oyalrfwgjw&t=646s) the Docker container has been just started for this RLM.

[10:50](https://www.youtube.com/watch?v=8oyalrfwgjw&t=650s) And now coming back to our execution, you can see that execution had just finished.

[11:00](https://www.youtube.com/watch?v=8oyalrfwgjw&t=660s) And in this execution, what you have seen, basically in the first step, model has written the, the REPL code that you can see here, and then it's built the evidence.

[11:12](https://www.youtube.com/watch?v=8oyalrfwgjw&t=672s) And after that, it also made the calls to the llm_query

[11:19](https://www.youtube.com/watch?v=8oyalrfwgjw&t=679s) with some prompt and got the result back. And after that, it gives the, the final answer. And as you can see here, we can have all this,

[11:31](https://www.youtube.com/watch?v=8oyalrfwgjw&t=691s) all this step coming back to the, the final answer.

[11:37](https://www.youtube.com/watch?v=8oyalrfwgjw&t=697s) And here you can see the-- it made the two tool calls and how many-- the tokens is used, uh, for this model, that you can see it here.

[11:48](https://www.youtube.com/watch?v=8oyalrfwgjw&t=708s) And the good thing is that you can see all these traces in the rlm-code repositories. So for example, you can see all the runs. This is the run that we just did.

[12:00](https://www.youtube.com/watch?v=8oyalrfwgjw&t=720s) You can see all the sessions and all the observability that you can plug it into any of your observ-- favorite observability platform.

[12:08](https://www.youtube.com/watch?v=8oyalrfwgjw&t=728s) So this is the CLI path we just demonstrated, but we also have this, um,

[12:17](https://www.youtube.com/watch?v=8oyalrfwgjw&t=737s) Kind of coding agent style experimental, uh, harness where you can try the same thing. So first of all, let's connect with the Gemini model.

[12:29](https://www.youtube.com/watch?v=8oyalrfwgjw&t=749s) So you can connect with the Gemini model using the command

[12:33](https://www.youtube.com/watch?v=8oyalrfwgjw&t=753s) connect. You can, you can have a provider and the model name. Now you are connected. So you can also run

[12:44](https://www.youtube.com/watch?v=8oyalrfwgjw&t=764s) the doctor command and see if everything is okay.

[12:55](https://www.youtube.com/watch?v=8oyalrfwgjw&t=775s) Seems like doctor command found some warning, but this is related to Deep Agents, ADK and other frameworks which is not relevant to this demo. And the interesting part where we will be seeing is basically you are sending the prompt.

[13:11](https://www.youtube.com/watch?v=8oyalrfwgjw&t=791s) So for what we did now, we ran the command, and we asked the question. We specify the budget so that we don't-- not spending too much, uh, on this run.

[13:21](https://www.youtube.com/watch?v=8oyalrfwgjw&t=801s) But once we do that, as you can see, you have maximum steps, recursion depth, and it completed. It's this run,

[13:32](https://www.youtube.com/watch?v=8oyalrfwgjw&t=812s) and coming back with the results. We can also see that th-this thing into the, the research lab, where we can see the spin has been completed. We can see some rewards.

[13:45](https://www.youtube.com/watch?v=8oyalrfwgjw&t=825s) We can also see the trajectory, which is important part, where we can see the all the RLM loop. For example, the, the REPL and the code and the final output.

[13:57](https://www.youtube.com/watch?v=8oyalrfwgjw&t=837s) So-- And also we can see the, the events, when it started and when it ended. So you can play around with this rlm-code terminal user interface, which is kind of harness, and you can experiment your RLM ideas in here.

[14:16](https://www.youtube.com/watch?v=8oyalrfwgjw&t=856s) So I'm going to quit this for now,

[14:18](https://www.youtube.com/watch?v=8oyalrfwgjw&t=858s) and let's switch back to the slides. In a nutshell, what we just saw, basically our context has been loaded.

[14:28](https://www.youtube.com/watch?v=8oyalrfwgjw&t=868s) We have some REPL code written to extract some snippets. We also saw the llm_query has been called to get some more context from another model. This is where the recursion comes in picture, and we got the final result.

[14:44](https://www.youtube.com/watch?v=8oyalrfwgjw&t=884s) And we got the, the traces in JSONL format that you can import it into the any of the observability platform of your choice.

[14:56](https://www.youtube.com/watch?v=8oyalrfwgjw&t=896s) We also saw these results coming from different files. You can take a look at the source code that will be available, uh, for you. Let's talk about the real thing, how AI engineer

[15:09](https://www.youtube.com/watch?v=8oyalrfwgjw&t=909s) could use these concepts in the real life.

[15:14](https://www.youtube.com/watch?v=8oyalrfwgjw&t=914s) And there are few things. For example, if you're dealing with a large source code and you want to, for example, root cause analysis or onboarding of the repositories or some unfamiliar repos.

[15:29](https://www.youtube.com/watch?v=8oyalrfwgjw&t=929s) So there are few use cases you can from here and probably try to use RLM concepts over there.

[15:37](https://www.youtube.com/watch?v=8oyalrfwgjw&t=937s) Basically, you can design your own harness, um, based on your needs, so that should capture the whole trajectory. All these things like the planning, coding, observation, subcall, budget, and the final output.

[15:51](https://www.youtube.com/watch?v=8oyalrfwgjw&t=951s) Now, coming back to the final point about RLM concepts and where it's been used.

[15:57](https://www.youtube.com/watch?v=8oyalrfwgjw&t=957s) I have recently came across a lot of the post on X saying the RLM concepts have been being used into the some of the proprietary things like the managed agent, dynamic workflows, using the RLM concepts under the hood.

[16:11](https://www.youtube.com/watch?v=8oyalrfwgjw&t=971s) So they have implemented one or more forms of RLM inside their agent harnesses. Recently, I saw that the Codex harness is writing the Python, Python code in the REPL that you can see to curate the context.

[16:26](https://www.youtube.com/watch?v=8oyalrfwgjw&t=986s) That is the one form of RLM I have seen myself. And obviously, Claude's managed agents or Gemini managed agents, they're all kind of concepts of RLM. So basically, you can get the harness in the sandbox, and then you can do the stuff.

[16:41](https://www.youtube.com/watch?v=8oyalrfwgjw&t=1001s) And the recent things about the dynamic workflows where one agent, given the, given the task, you can spawn multiple agents that have their separate sandboxes. They can work together and give back the final results.

[16:54](https://www.youtube.com/watch?v=8oyalrfwgjw&t=1014s) And the idea is basically generally coming from the, um, RLMs. A lot of software factories concepts are probably using the RLMs, but we are not sure yet. However, some of the Claude Code engineers from Anthropic has accepted on X that they have used concepts of RLM.

[17:14](https://www.youtube.com/watch?v=8oyalrfwgjw&t=1034s) You can use this RLM concept on your large context repository, and if you have any questions, then feel free to reach out to me.

[17:24](https://www.youtube.com/watch?v=8oyalrfwgjw&t=1044s) And finally, thank you so much for listening to my talk.
