Talk introducing Recursive Language Models (RLM), a pattern from an MIT paper for handling large codebases with coding agents. RLM loads a repository into a programmable REPL where the model writes code to inspect the repo and recursively delegates focused sub-questions via llm_query. The talk includes a live end-to-end demo on RLM Code (independent, unofficial) running on both local and cloud models, with a fully inspectable trajectory. # Channel Identity Observations: RLM Talk (Shashi, Superagentic AI) ## Explicit Self-Description - **Speaker identity stated on stage:** "My name is Shashi. I a founder of super aentic [Superagentic AI]." - **Company affiliation and product claim:** "our own library that we created at super agentai called RLM code" — the channel/company presents an open-source tool: "It is completely open source project that you can use it and play with it." - **Positioning of the product:** "RLM code is just a reference implementation to demonstrate how the RLM concepts works under the hood." - **Event context:** "welcome to this online track talk for the AI engineer world fair 2026" — presented as a conference/technical talk format. ## Claimed Scope of the Channel's Content - **Core topic:** "RLM also known as recursive language models and how we can use those concepts or larger code bases." - **Practitioner-oriented framing:** "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." - **Coverage of the RLM pattern itself:** RLM is "a concept and a pattern and you can implement that concept and pattern in your own way" — with references to MIT's paper, official implementations ("RLM and RLM minimal"), and DSPy's implementation. - **Flexibility claims about RLM code:** "you can run it with the local model. You can run with run it with cloud-based model. You can plug into any observability framework of your choice." - **Adoption/context claims:** "some of the cloud code engineers from anthropic has accepted on X that they have used concepts of RLM" and "RLM concepts have been being used into the some of the proprietary things." ## Observable Presentation Evidence ### Intended Audience - **AI engineers and coding-agent practitioners**, evidenced by: - "how AI engineer could use this concepts in the real life" - "If you're using the coding agents for smaller repos or monor repos, they works exceptionally well. But if you have ever tried it with the monor repos with the large context you know there's a context problem" - "If you have used the coding agents then you probably saw that there are different approaches that other coding agent harnesses have taken" ### Demonstrated Content Style - **Hands-on live demonstration:** "let me jump into the live demo" — shows a Docker sandbox ("we're using the docker as a sandbox"), a CLI run against a demo repo, token usage, and traces: "you can see all the runs... all the sessions and all the observability." - **Teaching via analogy:** the lead-engineer analogy — "Imagine you are a lead software engineer and assigned to the new project with a huge code base... engineer probably asked to another engineer or expert." - **Concept-first, implementation-second structure:** problem framing ("what's the problem?"), survey of existing approaches (grep search, semantic search, context compression, memory solutions), core thesis, then demo, then real-world use cases. ### Scope Demonstrated - **Practical use cases highlighted:** "root cause analysis or on boarding of the repositories or some unfamiliar repos." - **Guidance for builders:** "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." - **Open invitation to engage:** "if you have any questions then feel free to reach out to me." ## Claims vs. Demonstrated Patterns | Type | Observation | Evidence | |---|---|---| | **Creator claim** | RLM code is a flexible, open-source reference implementation | "You can plug into any observability framework of your choice" | | **Demonstrated** | Live CLI and experimental harness runs with Gemini | "So we are going to use with the Gemini... you can connect with the Gemini model using the command connect" | | **Creator claim (third-party)** | Anthropic/Codex engineers use RLM concepts | "cloud code engineers from anthropic has accepted on X" (attributed, unverified within the talk) | | **Demonstrated** | Talk emphasizes teaching transferable patterns over promoting a product | "RLM itself is a concept and a pattern and you can implement that concept and pattern in your own way" | # Delivery Observations: "RLM: Recursive Language Models for Large Codebases" — Shashi, Superagentic AI ## Tone & Register - **Conversational, conference-talk style**: The speaker opens with a standard greeting and framing: *"Hello and welcome to this online track talk for the AI engineer world fair 2026."* - **Explainer tone**: Rather than presenting original research, the speaker positions himself as an interpreter of others' work: *"the RLM paper has been published by MIT and friends... But the purpose of this talk is how you can use the concepts of RLM and you can use into your own workflow."* - **Occasional hedging and informal asides** during the live demo: *"Seems like Dr. Command found some warning. But this is related to deep agent ADK and other frameworks which is not relevant to this demo."* ## Teaching Habits & Structure - **Problem → concept → analogy → demo → use cases arc**: The talk follows a visible scaffold: 1. *"So first of all, what's the problem?"* 2. *"First of all let's explore the RLM idea."* 3. *"Let me summarize this giving you a simple analogy."* 4. *"So let me jump into the live demo now."* 5. *"how AI engineer could use this concepts in the real life"* - **Recurring signposting phrases** (appearing multiple times): - *"So basically"* — used at least 6 times to introduce simplifications (*"So basically there's a file system and the coding agent harnesses search using these tools"*) - *"First of all"* — used to open major sections - *"Let me summarize"* / *"In a nutshell"* — used to recap after concept and demo sections (*"In a nutshell, what we just saw basically our context has been loaded."*) - *"Now let's switch the gear"* / *"So let's switch back to the slides"* — explicit transitions between demo and slides - **Analogy-based explanation**: A single extended analogy (lead engineer exploring a monorepo) carries the core concept: *"Imagine you are a lead software engineer and assigned to the new project with a huge code base."* The analogy is then mapped term-by-term onto RLM components (repo, REPL, LLM query, recursion). - **Justification of scenario choice**: The speaker pauses to explain why codebases, not books or dictionaries: *"the codebase is not only just um the text, it is a structured data."* ## Vocabulary & Recurring Terms - **Dense repetition of domain vocabulary**: "concept(s)" (very frequent), "harness," "context," "loop," "ripple" (apparent transcription of "REPL"), "recussion" (transcription of "recursion"), "monor repo(s)" (monorepo), "observability," "sandbox." - **Clarifying definitions embedded in speech**: *"LLM query is basically ally asking another model environment to get an answer from."* - **Non-native-English patterns** observable throughout: dropped articles ("large project like the files and docs and texts and configs"), agreement variants ("they works exceptionally well," "this problem get worse," "the loop get terminated"), and malapropisms ("prove these concepts" for "prove/validate," "he stucks"). ## Live Demo Delivery - **Walkthrough narration of on-screen actions**: *"So right now you can see we're using the docker as a sandbox. If you see the docker container has been just started for this RLM."* - **Repeated pointing to visibility/traceability as a benefit**: *"you can see all the step coming back to the the final answer"* and *"the good thing is that you can see all these traces in the RLM code repositories."* - **Handles a live hiccup transparently** rather than editing past it (the doctor-command warning noted above). ## Evidence & Uncertainty Language - The speaker **explicitly flags uncertainty** when speculating about industry adoption: *"A lot of software factories concepts are probably using the RLMs but we are not sure yet. However, some of the cloud code engineers from anthropic has accepted on X that they have used concepts of RLM."* - **Attribution habit**: credits sources by name and platform — *"Omar is author of RLM and he is also author of another popular framework called DSP."* ## Isolated vs. Stable Patterns - **Stable patterns** (well-supported by repetition): "So basically," section signposting with "first of all," recap phrases ("in a nutshell," "let me summarize"), the concept/harness framing, and the repeated emphasis on observability and open source. - **Isolated moments**: The extended lead-engineer analogy appears once; the X/industry-adoption discussion appears once near the end. These are single-occurrence features, so no pattern is claimed for them. # Position Record: RLM Talk — Shashi (Superagentic AI) ## Speaker - **Shashi**, founder of Superagentic AI, speaking at the **AI Engineer World Fair 2026** online track. ## Context / Framing - The **RLM paper was published by MIT and colleagues**; Shashi explicitly notes the talk's purpose is *not* the paper itself, but **how to apply RLM concepts in your own workflow and harnesses**. ## The Problem Stated - Coding agents work **exceptionally well on small repos**, but performance **degrades as context grows**, especially in **large monorepos**. - Existing harness approaches he enumerates: - **Tool-based search** (e.g., grep-style file-system search) - **Semantic/local search** to curate context - **Long-context compression / summarization** - **Memory solutions** for persisting agent memory ## Core RLM Thesis (as presented by Shashi) - **Externalize context management into a programmable execution environment**: the repository is treated as data the model operates on. - The model **writes code (Python REPL) to inspect, slice, and compute** relevant chunks, which are fed into the main context window rather than loading everything. - Can also serve as a **memory layer** for coding agents. ### Lead-engineer analogy - A lead engineer on a new monorepo doesn't read line by line: they inspect structure, note dependencies, ask specialists. In RLM: - **REPL** ≈ the engineer's notebook - **LLM query** ≈ asking another specialist (this sub-questioning is the **recursion**) - Loop: repo → model writes REPL code → bounded observation → optional LLM query → repeat until final synthesis. ## Why codebases specifically - Codebases are **structured data** — directories, tests, imports, dependencies, configs, images — not just text; the model must **reason over structure**, which is why Shashi chose this domain to demonstrate RLM. ## RLM Code (Superagentic's library) - **RLM Code**: open-source "research playground" implementing RLM concepts; Shashi stresses it's a **reference implementation** of the pattern, not a modification. - Distinguishes it from the authors' **RLM / RLM-minimal repos** and **DSPy's RLM implementation** (Omar is author of both RLM and DSPy, per Shashi) — but they should be treated as **completely different things**: RLM is a pattern implementable in many ways. - Flexibility claims: runs with **local or cloud models**, plugs into **any observability framework** and frameworks like "padenti" [sic — likely Padient/"ADK"-style frameworks as mentioned; wording unclear in transcript] or Google ADK. ## Live Demo Claims - Demo run (using Gemini, Docker sandbox) showed: model **wrote REPL code**, built evidence, made **two LLM query tool calls**, produced a final answer, with token usage and **JSONL traces** viewable/importable into observability platforms. - Also demonstrated an experimental **TUI coding-agent-style harness** with `connect`, `doctor` (which showed a warning Shashi qualified as unrelated to the demo), and a `run` command with a **budget** and **max recursion depth**. - Research-lab view shows runs, rewards, and trajectories. ## Practical Use Cases Suggested - **Root cause analysis**, **onboarding onto unfamiliar repos**, large source code tasks. - Recommends designing your own harness capturing the full trajectory: planning, coding, observation, subcall budget, final output. ## Claims About Industry Adoption (with explicit uncertainty) - Shashi says he has "recently come across a lot of posts on X" claiming RLM concepts are used in proprietary systems: - **Codex harness** writing Python in a REPL to curate context — stated as something **he has "seen myself"**. - **Claude managed agents / Gemini managed agents** described as "kind of concepts of RLM." - **Dynamic workflows** with multiple agents in separate sandboxes — idea "generally coming from" RLMs. - **Software factories** "probably" using RLMs — **"we are not sure yet"** (uncertainty preserved). - Claims **some Claude Code engineers from Anthropic have "accepted on X"** that they used RLM concepts. - Note: these adoption claims are based on his reading of social posts, with varying degrees of hedging. ## Summary of Demo Flow Context loaded → REPL code writes snippets → LLM query called for more context (recursion) → final result → JSONL traces importable into observability tooling. # Video Attribution & Provenance Record **Video ID:** `01a15ca8-a796-75cc-8a11-1cd7c6da681b` **Title:** RLM: Recursive Language Models for Large Codebases - Shashi, Superagentic AI **Venue (per speaker):** AI Engineer World Fair 2026, online track talk ## Speakers & Roles | Speaker | Role | Notes | |---|---|---| | Shashi | **Creator / Presenter** | Self-identified: "My name is Shashi. I'm a founder of Superagentic [AI]" — sole speaker throughout | No guests, narrators, or other identified speakers appear in the transcript. ## Referenced Sources & Third-Party Claims ### Cited Paper & Implementations - **RLM paper** — attributed by speaker to "MIT and friends"; described as published with a full paper available for reading. - **RLM and RLM minimal** — official authors' implementations on GitHub. - **DSPy** — framework by **Omar**, whom the speaker identifies as an author of RLM; DSPy contains an RLM implementation. Speaker explicitly cautions DSPy and RLM are "completely different" (RLM is a pattern). - **RLM code** — the speaker's own open-source library from Superagentic AI, described as a research playground / reference implementation with documentation and a GitHub repository. ### Tools/Frameworks Mentioned - Gemini (used in live demo), Docker (sandbox), Codex harness, Claude managed agents, Anthropic, Google ADK / Deep Agent ADK, Padenti (per transcript spelling), observability frameworks (JSONL trace import). ### Third-Party Claims (attributed, unverified) - Posts on **X** claiming proprietary managed agents/dynamic workflows use RLM concepts under the hood. - Speaker states he personally saw the **Codex harness** writing Python code in a REPL to curate context, calling it "one form of RLM." - "Some of the cloud code engineers from Anthropic has accepted on X that they have used concepts of RLM." - Software factories "probably" using RLMs — **explicitly flagged by speaker as uncertain** ("we are not sure yet"). ## Promotional Segments - **RLM code segment** (~mid-talk): presenter showcases his own company's open-source library — landing page, documentation, GitHub repo, live demo, and CLI/TUI harness. Flag as **self-promotional** (company-affiliated product), though he frames it as a reference implementation of RLM concepts. ## Availability & Evidence Limits - **Comments:** No comment availability information supplied in source material. - **Curated metadata:** None supplied beyond the title. - **Uncertainty notes:** "Software factories" RLM usage explicitly uncertain; X-post claims are speaker-relayed, unverified third-party assertions. Transcript contains no timestamps. Hello and welcome to this online track talk for the AI engineer world fair 2026. Today we're going to explore the concept of RLM also known as recursive language models and how we can use those concepts or larger code bases. My name is Shashi. I a founder of super aentic. First of all, let's be clear that RLM paper has been published by MIT and friends. As you can see, there's a full paper. 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. So first of all, what's the problem? If you're using the coding agents for smaller repos or monor repos, they works exceptionally well. But if you have ever tried it with the monor repos with the large context you know there's a context problem as the context grows the performance degrade and if you're working with the monor repose 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. If you have used 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 grab. So basically there's a file system and the coding agent harnesses search using these tools. The second approach you 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 and there are some memory solutions available in the market as well that you can use to persist the memory for the coding agent. First of all let's explore the RLM idea. 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. 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 value you can then feed into the main context window. So basically rather than putting everything into the model's context create a separate dedicated environment give them a coding agent or ripple and then model write the code to curate the context that can be used into the main. 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. 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. Imagine that's a monor repo. How does that lead engineer deals with the code? So rather than reading 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 if something else uh is not understood by the repository engineer probably asked to another engineer or expert to get some ideas and the same concepts applied in RLM so large project like the files and docs and texts and configs because repository has a lot of things and the programmable ripple it's kind of a notebook that engineer makes a note about the codebase that can be used researching he may be using other techniques or maybe it's writing some script to search something from the repo and then if he stucks then he ask another engineer or specialist where it come to the LLM query and LLM query is basically ally asking another model environment to get an answer from and once they get answer then the loop continues and at the end it returns the clean note synthesis. So the recussion part here is engineer ask another specialist using LLM query that can be one question or that can be number of questions. So this is where the recussion comes in picture. Loop is basically your repo as your context and then the model writes the ripple code to get some relevant context that returns the bounded observation and if we if loop needs more information it passes through the llm query where it ask another language model or another system to get the response return the value and continue the loop. and the loop get terminated until we get a final results. Why we talking about the code base and not the big context in terms of like other things for example books or dictionaries 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. So the codebase 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 a code basis to prove these concepts of RLM. Now let's switch the gear and talk about our own library that we created at super agentai called RLM code. You can see RLM codes landing page here where this is just a research playground where you can the concepts of RLM. 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 and play with it. RLM itself is a concept 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 minimal. 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 DSP. So DSP got RLM implementation inside it. 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 in the similar way we implemented RLM code as our own independent harness that we will be using in this live demo. RLM code is just a reference implementation to demonstrate how the RLM concepts works under the hood. 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 ripple execution. However, you can run it with the 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. You can also plug it into the framework of your choice. For example, you can use padenti or Google ad or something similar framework and implement ideas of RLN 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. And we will see how these things works in a in a practice. 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 has been created where the python ripple has written a code and where it's passed to the lm query and how we get the final results. 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 ripple and then observation and the final recursive language output. So let me jump into the live demo now. Okay, let's do the live demo of this concepts of RLM and RLM code and how it works in a the larger code basis. 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 and then we have some instructions that you can follow along um yourself. So basically 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 happened. So right now you can see we're using the docker as a sandbox. If you see the docker container has been just started for this RLM. And now coming back to our execution you can see that execution had just finished. And in this execution what you have seen basically in the first step model has written the ripple code that you can see here. And then it's built the evidence and after that it also made the calls to the LLM query 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 all the step coming back to the the final answer. And here you can see the it made the two tool calls and how many the tokens is used for this model that you can see it here 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. You can see all the sessions and all the observability that you can plug it into any of your obser favorite observability platform. So this is the CLI path we just demonstrated but we also have this um kind of coding agent style experimental harness where you can try the same thing. So first of all let's connect with the Gemini model. So you can connect with the Gemini model using the command connect. You can you can have a provider and the model name. Now you are connected. So you can also run the doctor command and see if everything is okay. Seems like Dr. Command found some warning. But this is related to deep agent ADK and other frameworks which is not relevant to this demo. And an interesting part where we will be saying is basically you are sending the prompt. So for what we did now we run the command and we ask the question we specify the budget so that we don't not spending too much uh on this run. But once we do that as you can see your maximum steps recussion depth and it completed it this run and coming back with the results. We can also see that this thing into the the research lab where we can see this spin has been completed. We can see some rewards. We can also see the trajectory which is important part where we can see the all the RLM loop for example the the ripple and the code and the final output. 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. So I'm going to quit this for now and let's switch back to the slides. In a nutshell, what we just saw basically our context has been loaded. We have some ripple code written to extract some snippets. We also saw the eleant query has been called to get some more context from another model. This is where the recussion comes in picture and we got the final result and we got the the traces in JSONL format that you can import it into the any of the observability platform of your choice and we also saw this 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 could use this concepts in the real life and there are few things for example if you're dealing with the large source code and you want to for example root cause analysis or on boarding of the repositories or some unfamiliar repos. So there are few use cases you can from here and probably try to use RLM concepts over there. 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 sub call budget and the final output. Now coming back to the final point about RLM concepts and where it's been used. 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. So they have implemented one or more for RLM inside their agent harnesses. Recently I saw that the codeex harness is writing the Python Python code in the ripple that you can see to curate the context that is one form of RLM I have seen myself and obviously the clouds manage 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 and the recent things about the dynamic workflows where one agent given the given the task you can spot on multiple agents that have their separate sandboxes. They can work together and give back the final results 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 cloud code engineers from anthropic has accepted on X that they have used concepts of RLM. 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. And finally, thank you so much for listening to my