Superagentic AI Speaks on RLM at the AI Engineer World’s Fair 2026

Shashikant Jagtap

Superagentic AI returned to the AI Engineer World’s Fair 2026 Online Track with a second talk, “RLM: Recursive Language Models for Large Codebases.” The session, delivered by Shashi Jagtap, Founder of Superagentic AI, is now published on the AI Engineer YouTube channel, and the full slide deck and demo repository are available online.

This talk follows our earlier Online Track session on TurboQuant and retrieval memory. Where that talk focused on retrieval efficiency, this one addresses a different bottleneck in agentic coding: what happens when the repository itself is too large for the agent to reason about reliably.

Watch the Talk

Why Large Codebases Break Coding Agents

Coding agents work well on small projects, but large repositories expose two failure modes. First, agents lose the architecture: retrieval returns fragments, and the global structure of the system never makes it into the reasoning. Second, agents drown in tool output: every search and file read dumps more text into the conversation, and as the context grows the useful signal shrinks. Search, retrieval, and longer context windows all help, but the talk argues that large repositories ultimately require stateful, structured investigation rather than a longer transcript.

The RLM Pattern

The talk introduces Recursive Language Models, a pattern from the MIT paper Recursive Language Models by Alex L. Zhang, Tim Kraska, and Omar Khattab. The core idea is to move the context out of the prompt and into a programmable execution environment. The slides describe the mental model as a senior engineer with a notebook: instead of trying to hold the entire repository in mind at once, the model works through it methodically, keeping notes as it goes.

Concretely, the loop demonstrated in the talk works like this:

  • The repository context is loaded into a Python REPL as a variable, not pasted into the prompt.
  • The model writes code to inspect that context, so it decides what to look at and when.
  • Observations are bounded, so tool output cannot flood the conversation.
  • The model can delegate focused sub-questions to a fresh model call through a recursive llm_query function available in the REPL namespace.
  • The run ends with an explicit FINAL() call that returns the answer.

Codebases are a natural fit for this pattern because repositories are structured and executable. The model does not have to treat the code as one long string; it can navigate it by module, dependency, and boundary.

The Live Demo

The talk includes a live demo of the loop running end to end on RLM Code, an independent, experimental implementation of the pattern built by Superagentic AI. RLM Code is not the official MIT RLM implementation; it is an unofficial harness used to make the mechanics inspectable. The demo repository ships a snapshot of the RLM Code source as the repository under analysis, so the demo shows the harness investigating its own codebase.

The demo makes a point of showing where each part of the loop lives: the model-written REPL code executes inside a Docker sandbox with networking disabled, the model HTTP calls happen from the host process, and the verified trajectory records exactly two model calls: one root planner call and one recursive llm_query subcall. Every step is recorded, so the whole trajectory can be inspected and replayed after the run.

Local or Cloud, Same Harness

A key theme of the talk is provider portability. The RLM loop is provider agnostic: the same harness, context handling, recursive llm_query, and finalization run identically whether the model is local or in the cloud, and only the provider and model settings change. The demo was validated on both a local Ollama model and Gemini, and RLM Code also supports OpenAI and Anthropic directly, plus OpenAI-compatible routes such as OpenRouter, Groq, DeepSeek, and Together, alongside local Ollama and LM Studio.

View the Slides

The full slide deck from the talk is available online: View the RLM AI Engineer World’s Fair 2026 slides

Try It Yourself

The demo repository is designed so that anyone can reproduce the talk on their own machine. It includes:

  • The React and TypeScript presentation used in the talk.
  • A Python CLI probe, scripts/rlm_probe.py, that runs the RLM loop against a repository.
  • A small RLM Code source snapshot used as the default analysis target.
  • Reusable prompts and practical use case notes for adapting the workflow to other repositories.

The README contains validated copy-paste commands for the local Ollama path and the Gemini path, and the probe can be pointed at any local repository by setting RLM_PROBE_REPO. There is also an option to run without Docker for a quick smoke test, with the trade-offs clearly documented.

Where RLM Fits

The pattern works best when the task is investigative and evidence heavy. Good fits include architecture mapping, onboarding to unfamiliar modules, cross-file security or reliability audits, refactor planning, dependency mapping, test gap analysis, incident investigation, and migration planning. It is not the right tool for tiny one-file edits or tasks where a quick search and a single file read are enough.

The talk also positions RLM relative to retrieval. RAG answers the question “which chunks look relevant.” RLM asks a different question: “what program should I run over this environment to understand the problem.” The two can work together, with retrieval narrowing the search space and RLM reasoning over the structured result.

Part of a Broader Superagentic AI Presence at AI Engineer World’s Fair

This session joins our earlier TurboQuant talk on the Online Track and the Harness Engineering side event we hosted during AI Engineer World’s Fair week. All three share the same focus: helping teams build more capable agentic systems with inspectable harnesses, better retrieval, and stronger engineering foundations.

Links

Superagentic AI will continue sharing work on agent harnesses, recursive language models, and practical infrastructure for coding agents working on real codebases.