WEBVTT

NOTE Sentence-level transcript of https://www.youtube.com/watch?v=8oyalrfwgjw

NOTE One cue per sentence. Cue ids are the line anchors on /transcripts/8oyalrfwgjw.html. A cue ends where the next begins, or 2 s after its last word.

s1
00:00:00.240 --> 00:00:08.000
Hello and welcome to this online track talk for the AI engineer world fair 2026.

s2
00:00:08.160 --> 00:00:19.920
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.

s3
00:00:19.920 --> 00:00:21.199
My name is Shashi.

s4
00:00:21.199 --> 00:00:23.920
I a founder of super aentic.

s5
00:00:23.920 --> 00:00:30.080
First of all, let's be clear that RLM paper has been published by MIT and friends.

s6
00:00:30.080 --> 00:00:32.719
As you can see, there's a full paper.

s7
00:00:32.719 --> 00:00:34.399
You can read about it.

s8
00:00:34.399 --> 00:00:43.680
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.

s9
00:00:43.680 --> 00:00:45.840
So first of all, what's the problem?

s10
00:00:45.840 --> 00:00:52.480
If you're using the coding agents for smaller repos or monor repos, they works exceptionally well.

s11
00:00:52.480 --> 00:01:03.600
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

s12
00:01:03.600 --> 00:01:05.760
this problem get worse.

s13
00:01:05.760 --> 00:01:14.960
In this talk we will see we selected the code base and the concept of RLMs are relevant for the larger code bases.

s14
00:01:14.960 --> 00:01:23.360
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.

s15
00:01:23.360 --> 00:01:28.320
Most common approach is searching using the tools like grab.

s16
00:01:28.320 --> 00:01:34.880
So basically there's a file system and the coding agent harnesses search using these tools.

s17
00:01:34.880 --> 00:01:40.640
The second approach you probably seen that the semantic search or the local search.

s18
00:01:40.640 --> 00:01:46.640
So idea here is basically you can search through the code and curate the context.

s19
00:01:46.640 --> 00:01:59.759
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

s20
00:01:59.759 --> 00:02:03.360
to persist the memory for the coding agent.

s21
00:02:05.200 --> 00:02:08.319
First of all let's explore the RLM idea.

s22
00:02:08.319 --> 00:02:17.680
Core thesis of the RLM is you need to externalize the context management into programmable execution environment.

s23
00:02:17.680 --> 00:02:23.760
Meaning you should have a separate dedicated environment so that model can operate on that.

s24
00:02:23.760 --> 00:02:30.480
In this case for example your whole repository is treated as a data that model can operate on.

s25
00:02:30.480 --> 00:02:42.000
Then model can write the code to inspect slice and compute the relevant chunks value you can then feed into the main context window.

s26
00:02:42.160 --> 00:02:57.200
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

s27
00:02:57.200 --> 00:02:59.360
that can be used into the main.

s28
00:02:59.360 --> 00:03:04.400
So it's another context management technique proved to be very effective.

s29
00:03:04.400 --> 00:03:09.920
Could be also be used as a memory layer for your coding agents.

s30
00:03:10.159 --> 00:03:14.080
Let me summarize this giving you a simple analogy.

s31
00:03:14.080 --> 00:03:22.800
Imagine you are a lead software engineer and assigned to the new project with a huge code base.

s32
00:03:22.800 --> 00:03:24.879
Imagine that's a monor repo.

s33
00:03:24.879 --> 00:03:28.400
How does that lead engineer deals with the code?

s34
00:03:28.400 --> 00:03:44.159
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

s35
00:03:44.159 --> 00:04:02.000
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

s36
00:04:02.000 --> 00:04:13.680
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

s37
00:04:13.680 --> 00:04:30.240
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

s38
00:04:30.240 --> 00:04:40.320
to get an answer from and once they get answer then the loop continues and at the end it returns the clean note synthesis.

s39
00:04:40.400 --> 00:04:50.800
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.

s40
00:04:50.800 --> 00:04:54.560
So this is where the recussion comes in picture.

s41
00:04:54.800 --> 00:05:13.600
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

s42
00:05:13.600 --> 00:05:25.039
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.

s43
00:05:25.039 --> 00:05:30.479
and the loop get terminated until we get a final results.

s44
00:05:31.360 --> 00:05:40.080
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?

s45
00:05:40.080 --> 00:05:50.400
It has directories, it has test, it has some imports, it has dependencies, it has tests, it has pictures, it has configuration files.

s46
00:05:50.400 --> 00:06:01.199
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.

s47
00:06:01.199 --> 00:06:08.319
That's why I chose this scenario to use a code basis to prove these concepts of RLM.

s48
00:06:09.280 --> 00:06:18.160
Now let's switch the gear and talk about our own library that we created at super agentai called RLM code.

s49
00:06:18.160 --> 00:06:28.720
You can see RLM codes landing page here where this is just a research playground where you can the concepts of RLM.

s50
00:06:29.039 --> 00:06:37.440
We have um documentation that you can take a look and there's a the GitHub repository.

s51
00:06:37.440 --> 00:06:46.400
It is completely open source project that you can use it and play with it.

s52
00:06:46.400 --> 00:06:56.160
RLM itself is a concept and a pattern and you can implement that concept and pattern in your own way.

s53
00:06:56.160 --> 00:07:04.000
There are official authors also wrote some implementation in their GitHub repos.

s54
00:07:04.000 --> 00:07:07.680
It's called RLM and RLM minimal.

s55
00:07:07.680 --> 00:07:12.639
You can refer that implementation of RLM in DSpy.

s56
00:07:12.639 --> 00:07:13.840
RLM.

s57
00:07:13.840 --> 00:07:21.680
So Omar is author of RLM and he is also author of another popular framework called DSP.

s58
00:07:21.680 --> 00:07:26.000
So DSP got RLM implementation inside it.

s59
00:07:26.000 --> 00:07:29.599
However, you should treat they are completely different.

s60
00:07:29.599 --> 00:07:34.720
So RLM is a pattern and you can implement in your own ways.

s61
00:07:34.720 --> 00:07:50.400
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.

s62
00:07:50.560 --> 00:07:58.960
RLM code is just a reference implementation to demonstrate how the RLM concepts works under the hood.

s63
00:07:58.960 --> 00:08:02.080
So we have implemented something called RLM mode.

s64
00:08:02.080 --> 00:08:04.479
We are using RLM as it is.

s65
00:08:04.479 --> 00:08:09.039
We are not adding anything on top of RLM's ideas and RLM's paper.

s66
00:08:09.039 --> 00:08:14.720
We are using the same concept of recursive calls ripple execution.

s67
00:08:14.720 --> 00:08:18.160
However, you can run it with the local model.

s68
00:08:18.160 --> 00:08:21.759
You can run with run it with cloud-based model.

s69
00:08:21.759 --> 00:08:25.440
You can plug into any observability framework of your choice.

s70
00:08:25.440 --> 00:08:31.680
And that gives you like a lot of flexibility around RLM.

s71
00:08:31.680 --> 00:08:35.599
You can also plug it into the framework of your choice.

s72
00:08:35.599 --> 00:08:45.040
For example, you can use padenti or Google ad or something similar framework and implement ideas of RLN over there.

s73
00:08:45.040 --> 00:08:57.760
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.

s74
00:08:57.760 --> 00:09:03.200
And we will see how these things works in a in a practice.

s75
00:09:03.200 --> 00:09:16.480
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

s76
00:09:16.480 --> 00:09:27.600
where the python ripple has written a code and where it's passed to the lm query and how we get the final results.

s77
00:09:27.600 --> 00:09:30.720
So that will be covered as part of the live demo.

s78
00:09:30.720 --> 00:09:34.000
So we can cover this everything here.

s79
00:09:34.000 --> 00:09:43.360
So in nutshell how it looks like is basically it creates the ripple and then observation and the final recursive language output.

s80
00:09:43.600 --> 00:09:46.399
So let me jump into the live demo now.

s81
00:09:46.399 --> 00:09:55.279
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.

s82
00:09:55.279 --> 00:10:05.680
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.

s83
00:10:05.680 --> 00:10:17.680
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

s84
00:10:17.680 --> 00:10:21.600
that you can follow along um yourself.

s85
00:10:21.600 --> 00:10:30.959
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.

s86
00:10:30.959 --> 00:10:36.480
So we will try this script and see what happened.

s87
00:10:37.279 --> 00:10:42.079
So right now you can see we're using the docker as a sandbox.

s88
00:10:42.079 --> 00:10:50.480
If you see the docker container has been just started for this RLM.

s89
00:10:50.480 --> 00:10:59.360
And now coming back to our execution you can see that execution had just finished.

s90
00:11:00.000 --> 00:11:08.959
And in this execution what you have seen basically in the first step model has written the ripple code that you can see here.

s91
00:11:08.959 --> 00:11:27.200
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.

s92
00:11:27.680 --> 00:11:37.040
And as you can see here we can have all this all the step coming back to the the final answer.

s93
00:11:37.040 --> 00:11:50.000
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

s94
00:11:50.000 --> 00:11:54.480
you can see all these traces in the RLM code repositories.

s95
00:11:54.480 --> 00:11:57.040
So for example you can see all the runs.

s96
00:11:57.040 --> 00:12:00.000
This is the run that we just did.

s97
00:12:00.000 --> 00:12:08.720
You can see all the sessions and all the observability that you can plug it into any of your obser favorite observability platform.

s98
00:12:08.720 --> 00:12:23.760
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.

s99
00:12:23.760 --> 00:12:29.120
So first of all let's connect with the Gemini model.

s100
00:12:29.120 --> 00:12:34.320
So you can connect with the Gemini model using the command connect.

s101
00:12:34.320 --> 00:12:38.959
You can you can have a provider and the model name.

s102
00:12:38.959 --> 00:12:41.680
Now you are connected.

s103
00:12:41.680 --> 00:12:54.320
So you can also run the doctor command and see if everything is okay.

s104
00:12:55.519 --> 00:12:58.240
Seems like Dr. Command found some warning.

s105
00:12:58.240 --> 00:13:04.480
But this is related to deep agent ADK and other frameworks which is not relevant to this demo.

s106
00:13:04.480 --> 00:13:10.959
And an interesting part where we will be saying is basically you are sending the prompt.

s107
00:13:10.959 --> 00:13:21.600
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.

s108
00:13:21.600 --> 00:13:35.040
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.

s109
00:13:35.040 --> 00:13:42.880
We can also see that this thing into the the research lab where we can see this spin has been completed.

s110
00:13:42.880 --> 00:13:45.600
We can see some rewards.

s111
00:13:45.600 --> 00:13:57.600
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.

s112
00:13:57.600 --> 00:14:04.320
So and also we can see the the events when it started and when it ended.

s113
00:14:04.320 --> 00:14:16.000
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.

s114
00:14:16.000 --> 00:14:22.959
So I'm going to quit this for now and let's switch back to the slides.

s115
00:14:23.360 --> 00:14:28.880
In a nutshell, what we just saw basically our context has been loaded.

s116
00:14:28.880 --> 00:14:33.680
We have some ripple code written to extract some snippets.

s117
00:14:33.680 --> 00:14:39.760
We also saw the eleant query has been called to get some more context from another model.

s118
00:14:39.760 --> 00:14:51.680
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

s119
00:14:51.680 --> 00:15:00.000
of the observability platform of your choice and we also saw this results coming from different files.

s120
00:15:00.000 --> 00:15:04.720
You can take a look at the source code that will be available uh for you.

s121
00:15:04.720 --> 00:15:20.399
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

s122
00:15:20.399 --> 00:15:29.920
and you want to for example root cause analysis or on boarding of the repositories or some unfamiliar repos.

s123
00:15:29.920 --> 00:15:37.199
So there are few use cases you can from here and probably try to use RLM concepts over there.

s124
00:15:37.199 --> 00:15:42.160
Basically you can design your own harness um based on your needs.

s125
00:15:42.160 --> 00:15:51.360
So that should capture the whole trajectory all these things like the planning coding observation sub call budget and the final output.

s126
00:15:51.360 --> 00:15:57.279
Now coming back to the final point about RLM concepts and where it's been used.

s127
00:15:57.279 --> 00:16:06.720
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

s128
00:16:06.720 --> 00:16:11.759
dynamic workflows using the RLM concepts under the hood.

s129
00:16:11.759 --> 00:16:18.800
So they have implemented one or more for RLM inside their agent harnesses.

s130
00:16:18.800 --> 00:16:30.240
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

s131
00:16:30.240 --> 00:16:41.680
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

s132
00:16:41.680 --> 00:16:51.920
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.

s133
00:16:51.920 --> 00:17:00.160
They can work together and give back the final results and the idea is basically generally coming from the um RLMS.

s134
00:17:00.160 --> 00:17:07.600
A lot of software factories concepts are probably using the RLMs but we are not sure yet.

s135
00:17:07.600 --> 00:17:14.559
However, some of the cloud code engineers from anthropic has accepted on X that they have used concepts of RLM.

s136
00:17:14.559 --> 00:17:19.439
You can use this RLM concept on your large context repository.

s137
00:17:19.439 --> 00:17:24.240
And if you have any questions then feel free to reach out to me.

s138
00:17:24.240 --> 00:17:28.319
And finally, thank you so much for listening to my