WEBVTT

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

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

s1
00:00:00.440 --> 00:00:01.440
Hello there.

s2
00:00:01.440 --> 00:00:14.880
My name is Raymond Whitcomb and today I'm going to talk about recursive coding agents, which is this idea of applying the lessons of recursive language models, RLMs, to coding agents.

s3
00:00:14.880 --> 00:00:27.240
This is some work that I have done both in my independent research um Raw Works uh and also more recently in my role at OpenProse.

s4
00:00:27.240 --> 00:00:31.320
So, to motivate this a little bit, we all want outcomes.

s5
00:00:31.320 --> 00:00:35.000
We all want agents that are working on our behalf.

s6
00:00:35.000 --> 00:00:45.360
We want reliable co-workers that are getting things done while we're doing something fun, while we're out on a hike, while we're cold chilling, while we're doing the do.

s7
00:00:45.360 --> 00:00:54.320
And my argument and my experience is that the bottleneck to this is not intelligence.

s8
00:00:54.320 --> 00:00:57.800
The models are intelligent enough.

s9
00:00:57.800 --> 00:00:59.320
They know all kinds of things.

s10
00:00:59.320 --> 00:01:02.600
They know the entire internet.

s11
00:01:02.600 --> 00:01:05.320
But they can't reliably deliver outcomes.

s12
00:01:05.320 --> 00:01:07.240
And so I can't trust them.

s13
00:01:07.240 --> 00:01:16.440
So, as a very simple example, you know, one day I get almost a fully working SaaS app from a single prompt, granted a long prompt.

s14
00:01:16.440 --> 00:01:23.920
The next day, and I swear this actually happened, cloud code empties the entire contents of my Solana wallet.

s15
00:01:23.920 --> 00:01:24.760
Oops.

s16
00:01:24.760 --> 00:01:25.480
Okay.

s17
00:01:25.480 --> 00:01:29.080
So, that doesn't really instill trust.

s18
00:01:29.080 --> 00:01:33.440
So, uh at the bottom here we got this this progression, okay?

s19
00:01:33.440 --> 00:01:39.280
And we all want to move towards the the one on the right where we're just sort of sitting there and meditating and and things are manifesting.

s20
00:01:39.280 --> 00:01:41.320
And so, where does that come from?

s21
00:01:41.320 --> 00:01:44.760
This is from the AI engineer code.

s22
00:01:45.960 --> 00:01:47.760
It's actually from the back of the t-shirt.

s23
00:01:47.760 --> 00:01:50.360
AI engineer code, November 2025.

s24
00:01:50.360 --> 00:01:53.440
Man, I hope I hope you're there.

s25
00:01:53.440 --> 00:01:54.880
If you weren't, watch it on YouTube.

s26
00:01:54.880 --> 00:01:57.440
It was it was amazing.

s27
00:01:57.440 --> 00:01:58.440
So, here's the thesis.

s28
00:01:58.440 --> 00:02:03.560
The thesis is today's agents are mismanaged geniuses.

s29
00:02:03.560 --> 00:02:10.679
The intelligence is there, and the missing layer is how do we specify and manage and reuse and verify the work.

s30
00:02:10.679 --> 00:02:19.720
So, this uh framing this phrase, the mismanaged genius, uh comes from Alex Zeng, Z Li, and Omar Khattab at MIT.

s31
00:02:19.720 --> 00:02:25.520
Um and Alex and Omar are uh part of the authors of the original recursive language models paper.

s32
00:02:25.520 --> 00:02:29.440
Uh I've also talked a little bit about this recently on Turning Post.

s33
00:02:29.440 --> 00:02:35.600
I forgot to mention that these slides are actually a website, recursivecodingagents.com.

s34
00:02:35.800 --> 00:02:39.959
So, you can click on them uh by going to this website.

s35
00:02:39.959 --> 00:02:42.640
So, everything I'm going to show in here is is interactive.

s36
00:02:42.640 --> 00:02:43.560
Okay.

s37
00:02:43.560 --> 00:02:47.760
What are recursive language models?

s38
00:02:47.760 --> 00:02:54.080
So, I like to say that in an RLM, the context itself is the object of computation.

s39
00:02:54.080 --> 00:03:01.120
Um and this is essentially a marriage of tool calling and reasoning.

s40
00:03:01.120 --> 00:03:03.760
We're going to talk a lot more more about that in the next slide.

s41
00:03:03.760 --> 00:03:08.280
But, the idea is that the full prompt is not a simple user query.

s42
00:03:08.280 --> 00:03:10.560
The full prompt is a variable.

s43
00:03:10.560 --> 00:03:14.280
The full prompt could be a file or many files.

s44
00:03:14.280 --> 00:03:21.440
Um and we have this read-evaluate-print loop, REPL, um that the agent is interacting with.

s45
00:03:21.440 --> 00:03:23.720
In the original paper, that's Python.

s46
00:03:23.720 --> 00:03:30.120
And the RLM is instructed to operate symbolically on that prompt.

s47
00:03:30.120 --> 00:03:33.280
So, don't just read the whole thing into your context window.

s48
00:03:33.280 --> 00:03:36.160
Um explore it symbolically.

s49
00:03:36.160 --> 00:03:49.120
And uh even more, you don't even directly explore symbolically, or maybe you do a little bit of poking around, but have uh other LLMs, uh and I guess other RLMs,

s50
00:03:49.120 --> 00:03:53.680
if you allow the recursion depth to be to be greater than one.

s51
00:03:53.680 --> 00:04:07.880
Uh have these uh other recursive um sub agents and and again we'll get uh a little bit into the the weeds of the the lingo um sub RLMs sub LLMs

s52
00:04:07.880 --> 00:04:15.120
uh do this symbolic manipulation to pick apart the answer and then work our way back up to a final answer.

s53
00:04:15.120 --> 00:04:19.959
So, it looks something like like this in this in this tree below.

s54
00:04:19.959 --> 00:04:33.680
So, my take here is that RLMs are the new reasoning models and I see this as the next paradigm of test time compute, inference time compute, whatever you want to call it.

s55
00:04:33.680 --> 00:04:40.400
And why does it seem obvious or maybe like hey, why is this even a thing?

s56
00:04:40.400 --> 00:04:46.720
Um I think it's very elegant because it's a very elegant marriage of two things, reasoning and code execution.

s57
00:04:46.720 --> 00:04:50.160
So, the code execution is reasoning.

s58
00:04:50.160 --> 00:05:01.840
Um and so instead of we we had long um we had chain of thought as a prompting strategy that evolved into reasoning models that explicitly expressed the chain of thought as the reasoning tokens.

s59
00:05:01.840 --> 00:05:12.400
We already had function calling, tool calling, parallel tool calling, um and RLMs really puts that together in a way that gets amazing results.

s60
00:05:12.400 --> 00:05:24.440
So, three very simple examples, one from the original paper U Long, the RLMs can process information that is many orders of magnitude larger than their context window, tens of millions

s61
00:05:24.440 --> 00:05:26.000
of tokens.

s62
00:05:26.000 --> 00:05:34.840
Uh what I showed in my own independent work was that the default RLM harness is itself a really powerful memory system.

s63
00:05:34.840 --> 00:05:48.080
Um so, RLM with no modifications is essentially like a top 10 memory system and like you know, up there with all the people custom making memory systems and there's probably billions of dollars going into that.

s64
00:05:48.080 --> 00:05:57.000
Um and uh with a little bit of modification, you you can get really amazing results uh using it as memory.

s65
00:05:57.000 --> 00:06:09.720
I was also able to show state-of-the-art results where the RLM framework and specifically the DSPy implementation of it was able to get state-of-the-art uh results on long reasoning tasks.

s66
00:06:09.720 --> 00:06:12.480
Now, there's this new benchmark Long CoT.

s67
00:06:12.480 --> 00:06:25.440
I won't go into the details in depth, but the idea of this benchmark was that the problems are hard specifically because they require so many um steps of reasoning

s68
00:06:25.440 --> 00:06:37.280
uh in in the like analysis sequence or the chain of thought um that most uh reasoning models, including the top ones, can't hold the thread for long enough.

s69
00:06:37.280 --> 00:06:52.680
Um if you allow the uh RLM to solve the problem uh using a combination of code and recursive calls to sub agents, then a very small model, Qwen 3.59B,

s70
00:06:52.680 --> 00:07:08.880
you could run this on a laptop, uh can actually beat So, Qwen 3.59B as an RLM can beat Opus and um and GPT-5.4, all the top frontier models as LLMs

s71
00:07:08.880 --> 00:07:11.280
on these long reasoning tasks.

s72
00:07:11.280 --> 00:07:15.040
So, they're extremely extremely powerful.

s73
00:07:15.600 --> 00:07:20.000
So powerful that they are arguably too hot to benchmark.

s74
00:07:20.000 --> 00:07:31.560
So, two examples here, on the left, a very high-profile uh case where um the Symbolica team has this RLM agent harness called Agentica.

s75
00:07:31.560 --> 00:07:46.160
Within hours of Arc AGI-3 being released, where the top scores of all the frontier models were around two or three percent, the uh Symbolica team showed 30-something percent.

s76
00:07:46.160 --> 00:07:47.240
This is crazy.

s77
00:07:47.240 --> 00:07:50.880
They blew it out of the water within hours using RLMs as a framework.

s78
00:07:50.880 --> 00:07:55.720
So much so that is uh, very much upset the Arc Prize team.

s79
00:07:55.720 --> 00:08:01.800
And so, uh, they gave them what I'm interpreting as a consolation tweet.

s80
00:08:01.800 --> 00:08:11.920
Uh, which as far as I'm reading the situation was essentially saying, you know, la-di-da, congratulations, um, but you didn't solve the problem the right way.

s81
00:08:11.920 --> 00:08:14.320
And we don't like RLM harnesses.

s82
00:08:14.320 --> 00:08:23.040
And so, uh, you can have this nice tweet, but we refuse to actually do the full private part of the ArcadeGI evaluation.

s83
00:08:23.040 --> 00:08:25.320
Uh, which to me is just insane.

s84
00:08:25.320 --> 00:08:38.479
Uh, in my own uh, work and and on the long COT benchmark, um, my results as well as Alex uh, from MIT, the RLM first author, uh, encouraged, let's say, the uh, the

s85
00:08:38.479 --> 00:08:45.320
uh, leaderboard maintainers to actually make like a separate open harness leaderboard.

s86
00:08:45.320 --> 00:08:55.640
Uh, so that the the results of the RLMs could be showcased without contaminating the original intent of the leaderboard, which was basically no tool calling is allowed.

s87
00:08:55.640 --> 00:08:58.160
So, my take on this is I don't care.

s88
00:08:58.160 --> 00:09:03.000
I don't care whether it's latent space or reasoning tokens or code execution.

s89
00:09:03.000 --> 00:09:04.080
I want results.

s90
00:09:04.080 --> 00:09:08.160
And I want AI programs that get those results.

s91
00:09:08.160 --> 00:09:12.120
Okay, so this can feel close to a lot of other things.

s92
00:09:12.120 --> 00:09:14.360
And I have I built a little rubric.

s93
00:09:14.360 --> 00:09:19.400
There's a companion GitHub repo for this that you can go through if you want to see.

s94
00:09:19.400 --> 00:09:21.960
Um, and so, what do we need to be an RLM?

s95
00:09:21.960 --> 00:09:33.880
We have an executable environment, the prompt is externalized, there's code that's actually the thing calling the model, the model is able to pick the decomposition of the problem into the sub calls or sub agents,

s96
00:09:33.880 --> 00:09:36.520
and the state itself is staying symbolic, right?

s97
00:09:36.520 --> 00:09:41.680
So, obviously plain LLMs and rag and things like that don't don't meet those.

s98
00:09:41.680 --> 00:09:47.520
Coding agents and sub-agents and loops, they get close, but they're not quite there.

s99
00:09:47.520 --> 00:09:51.360
And again, this rubric here is not to like start fights or nitpick.

s100
00:09:51.360 --> 00:09:57.960
It's just trying to explain like what what's the essence of of RLM and recursive coding agents.

s101
00:09:57.960 --> 00:10:02.200
Another example that's close but no cigar would be hardcoded map reduces.

s102
00:10:02.200 --> 00:10:13.640
And I would put this this project of lambda RLM in that category, which is essentially a way of saying, "Okay, I'm going to decompose the problem using lambda calculus into a map reduce."

s103
00:10:13.640 --> 00:10:18.520
And then there are like LLM calls in that executing the map reduce.

s104
00:10:18.520 --> 00:10:24.440
But the But the LLM is not deciding or the RLM is not deciding how to decompose the problem.

s105
00:10:24.440 --> 00:10:32.040
And that I see as like a key element of this that makes it very agent native, you might say.

s106
00:10:32.040 --> 00:10:36.040
Okay, so now RLMs, what about recursive coding agents?

s107
00:10:36.040 --> 00:10:37.640
Okay, it looks the same to me.

s108
00:10:37.640 --> 00:10:41.680
We just swap RLMs and LLMs for agents and sub-agents.

s109
00:10:41.680 --> 00:10:43.720
And don't we have the same thing?

s110
00:10:43.720 --> 00:10:46.200
And yeah, you do.

s111
00:10:46.200 --> 00:11:01.720
And I think that you could take this perspective of haha, trick question, like RLM is a coding agent and it's already recursive, so what did I And that's fine, and I don't think that argument is wrong,

s112
00:11:01.720 --> 00:11:03.760
but it doesn't really move anything forward.

s113
00:11:03.760 --> 00:11:15.400
And so, what I'm interested in is this question of how can we apply the principles of RLMs to coding agents and make them actually useful for coding agents.

s114
00:11:15.400 --> 00:11:23.440
And I've been very obsessed with this problem since the October RLM blog post came out in 2025.

s115
00:11:23.440 --> 00:11:28.040
Okay, so I'll show some of my experiments on recursive coding agents.

s116
00:11:28.040 --> 00:11:35.280
The first one was simply wrapping Alex's RLM package as a CLI.

s117
00:11:35.280 --> 00:11:42.040
So, the idea was I just want to give my coding agent an RLM as a tool call.

s118
00:11:42.040 --> 00:11:49.440
So, let's say we go we need to go sift through a 100 million token corpus.

s119
00:11:49.440 --> 00:11:54.360
Uh well, now I just use this that tool and then the RLM does the RLM thing.

s120
00:11:54.360 --> 00:11:56.200
So, that's interesting.

s121
00:11:56.200 --> 00:11:57.960
And it can be very useful.

s122
00:11:57.960 --> 00:12:01.840
Uh and a few other people have built uh things like that.

s123
00:12:01.840 --> 00:12:04.920
Uh but then I thought, "Well, what would it really mean?

s124
00:12:04.920 --> 00:12:11.440
What would be possible or how could it be possible to make the coding agent fully recursive?

s125
00:12:11.440 --> 00:12:19.480
So, the coding agent harness like calls itself, like the exact version of itself.

s126
00:12:19.480 --> 00:12:22.120
Um and how might you implement that?

s127
00:12:22.120 --> 00:12:25.160
And that is what I called Y pie.

s128
00:12:25.160 --> 00:12:30.920
Uh Y stands for the lambda calculus uh Y combinator.

s129
00:12:30.920 --> 00:12:35.960
And pie, in case you haven't heard of it, is really awesome coding agent.

s130
00:12:35.960 --> 00:12:41.000
It's incredibly minimal and it's specifically designed to be extensible.

s131
00:12:41.000 --> 00:12:53.480
So, Mario uh wants you to write extensions for pie for new features that you would like rather than trying to stuff your ideas into the the main um agent.

s132
00:12:53.480 --> 00:12:57.880
So, it's meant to be a very minimal core that you extend however you like.

s133
00:12:57.880 --> 00:13:03.760
And when I originally had the uh recursive coding agent idea, I wanted to do it with pie.

s134
00:13:03.760 --> 00:13:09.040
I was not able to use pie extensions to achieve this goal.

s135
00:13:09.040 --> 00:13:13.360
Um and so, I had to fork it instead.

s136
00:13:13.360 --> 00:13:23.200
I'm very excited to report that in anticipation of this talk, I revisited this and now pie has evolved um and the pie extensions have evolved such that you can

s137
00:13:23.200 --> 00:13:26.040
uh make it fully recursive with a pure extension.

s138
00:13:26.040 --> 00:13:35.360
So, I have both the pure recursive um extension pi recursive uh package as well as the y pi wrapper that is like a convenience wrapper for this.

s139
00:13:35.360 --> 00:13:42.760
So, this is very quite literally a recursive coding agent in the sense that pi calls pi calls pi calls pi.

s140
00:13:42.760 --> 00:13:44.960
You can set the depth however you want.

s141
00:13:44.960 --> 00:13:49.840
Um and now I want to show a few other notable projects in the space.

s142
00:13:49.840 --> 00:13:54.520
So, obviously there's the original uh implementation from Alex RLM.

s143
00:13:54.520 --> 00:14:01.640
DSPY pi.rlm is uh my go-to uh when I'm especially doing benchmarking.

s144
00:14:01.640 --> 00:14:06.520
Um that's how I got all these amazing results uh on some of these benchmarks.

s145
00:14:06.520 --> 00:14:12.480
AXE, I think is a very interesting one because it's incredibly agent native.

s146
00:14:12.480 --> 00:14:18.840
So, the AXE started out as a TypeScript variation on DSPY.

s147
00:14:18.840 --> 00:14:31.280
When RLM's came out, they obviously implemented it uh but they did it in this way that's um enables then AXE agent to like write a whole TypeScript interface to another AXE agent

s148
00:14:31.280 --> 00:14:38.839
and go all the way down uh the the recursive rabbit hole um which I think is really cool and very interesting.

s149
00:14:38.839 --> 00:14:46.640
Just to showcase that this like REPL could be anything, there's a an example from Dan at OpenProse who made the Unix RLM.

s150
00:14:46.640 --> 00:14:51.839
This is pure bash and the environment is just the Linux file system.

s151
00:14:51.839 --> 00:14:57.360
So, that's a whole another angle of thinking about uh what's possible with RLM.

s152
00:14:57.360 --> 00:15:08.600
And then lastly, and we'll talk more about OpenProse um but uh OpenProse as a language uh actually enables you to convert any coding agent into an RLM.

s153
00:15:08.600 --> 00:15:11.960
I'll talk a little bit more about how to do that towards the end of the talk.

s154
00:15:11.960 --> 00:15:28.600
Uh and then the OpenProse repo also contains a harness that executes it's a coding agent harness that uh will let you use Codex SDK or Cloud Code underneath and do an RLM style execution of these prose programs.

s155
00:15:28.600 --> 00:15:31.960
So, is Cloud Code an RLM?

s156
00:15:31.960 --> 00:15:35.080
This is like the the question that keeps getting asked.

s157
00:15:35.080 --> 00:15:41.880
And the original answer on the day release day of the blog post was no, no, no, it's not.

s158
00:15:41.880 --> 00:15:48.080
Uh but it was literally the first question that was asked or like asked on the very same day uh to the launch tweet.

s159
00:15:48.080 --> 00:15:51.760
Um it's basically saying, "Hey, this is Cloud Code subagents, right?"

s160
00:15:51.760 --> 00:15:59.240
Uh go back to my rubric if you want to like dig into some of the the nitty-ditty nitty-gritty details.

s161
00:15:59.240 --> 00:16:01.560
Um but arguably now it is.

s162
00:16:01.560 --> 00:16:10.800
So, uh over here on the right we see Omar saying, "Hey, congratulations Anthropic, uh Cloud Code is finally an RLM now that you have dynamic workflows."

s163
00:16:10.800 --> 00:16:12.320
So, so what changed?

s164
00:16:12.320 --> 00:16:21.480
And I think this is an interesting way of explaining um what's powerful about recursive coding agents and what RLM's even are um by using this example.

s165
00:16:21.480 --> 00:16:32.240
So, dynamic workflows were released just a few weeks ago um and they make Cloud Code recursive or capable of doing these recursive uh workflows.

s166
00:16:32.240 --> 00:16:37.200
Uh I would highly encourage you to read this blog post called A Harness for Every Task.

s167
00:16:37.200 --> 00:16:40.480
It shows six different workflow patterns that are very powerful.

s168
00:16:40.480 --> 00:16:43.920
Obviously, there's many more that you can achieve.

s169
00:16:43.920 --> 00:16:50.280
And just to to show it, I I wrote two uh workflows for Cloud Code.

s170
00:16:50.280 --> 00:17:02.839
Uh one that is explicitly not an RLM, so that's like a hard-coded map reduce workflow, and one that I'm arguing is, that is uh you could kind of think of it as like deep research over a file system.

s171
00:17:02.839 --> 00:17:15.640
So, you know, pick pick a handle, um assign that to an agent, have it go do some analysis, bring back what it finds, etc. Uh again, these are in the companion repo.

s172
00:17:16.000 --> 00:17:18.760
Uh and then now to open prose.

s173
00:17:18.760 --> 00:17:22.040
So, so dynamic workflows are cool.

s174
00:17:22.040 --> 00:17:23.439
They're only in Claude code.

s175
00:17:23.439 --> 00:17:25.280
They're also not the only way to do this.

s176
00:17:25.280 --> 00:17:26.680
So, what if you don't like Claude code?

s177
00:17:26.680 --> 00:17:30.360
Or what if you do like Claude code, but you don't want to use dynamic workflows?

s178
00:17:30.360 --> 00:17:31.640
You want something else.

s179
00:17:31.640 --> 00:17:33.600
So, this is what open prose is all about.

s180
00:17:33.600 --> 00:17:38.920
So, open prose is technically a programming language, but it is not compiled by your computer.

s181
00:17:38.920 --> 00:17:41.560
It's compiled by your coding agent.

s182
00:17:41.560 --> 00:17:44.280
Um, it's a markdown spec.

s183
00:17:44.280 --> 00:17:45.800
It's logical English.

s184
00:17:45.800 --> 00:17:49.480
You don't need to learn any kind of crazy syntax.

s185
00:17:49.480 --> 00:18:01.640
And there's actually a command prose write that will get Claude code or Codex or your favorite or Pi or your favorite coding agent to write a dot prose dot md file for you.

s186
00:18:01.640 --> 00:18:13.080
Um, so in that way it's similar to the the um, Claude code um, ultra code command where it like decide and write the workflows for you.

s187
00:18:13.080 --> 00:18:23.560
And the the prose has the ability to turn any agent that's got a file system and sub agents into an RLM.

s188
00:18:23.560 --> 00:18:25.240
So, this is open source repo.

s189
00:18:25.240 --> 00:18:26.400
You can check it out.

s190
00:18:26.400 --> 00:18:33.520
Um, and I've also written uh, a little bit more in depth about this for Turing Post in this article.

s191
00:18:33.520 --> 00:18:41.920
And the key thing that I want to bring up with regards to the RLMs is that open prose can explicitly declare the sub agent work.

s192
00:18:41.920 --> 00:18:49.440
So, again, I've made two kind of demo prose dot md files that are in this companion repo if you want to dig into the code.

s193
00:18:49.440 --> 00:18:51.720
I'm not going to do that here in the slides.

s194
00:18:51.720 --> 00:19:01.920
Uh, where you can break a problem up into smaller pieces that are assigned to sub agents, verify the work of those sub agents um, in the in the parent

s195
00:19:01.920 --> 00:19:03.560
agent session.

s196
00:19:03.560 --> 00:19:14.880
Uh, and what's even cooler is you can actually in open prose to the features that I added to the language or that you can add skills and tools as explicit dependencies.

s197
00:19:14.880 --> 00:19:29.200
So, you can imagine a workflow where certain sub agent needs a very specific skill to do its role in the workflow or must have access to a certain CLI tool,

s198
00:19:29.200 --> 00:19:31.600
for example, or it can't run and do its job.

s199
00:19:31.600 --> 00:19:48.080
And so, there's a way in Pros to actually wire those in as dependencies to ensure that um not only that the way the work is done um is what you want, but actually that the sub agents are specifically configured

s200
00:19:48.080 --> 00:19:55.560
with the tools and skills that they need to successfully do the work that you are declaring in the Pros contract.

s201
00:19:55.560 --> 00:19:57.360
Okay, super cool.

s202
00:19:57.360 --> 00:19:58.440
What can you actually do?

s203
00:19:58.440 --> 00:20:04.120
So, I've got two examples from Cloud Dynamic Workflows, two examples from Open Pros.

s204
00:20:04.120 --> 00:20:15.040
Uh repo scale migrations, this was kind of the launch post example, refactor like a huge thing uh all with a big swarm in parallel and then merge the whole thing together.

s205
00:20:15.040 --> 00:20:16.440
That's super cool.

s206
00:20:16.440 --> 00:20:29.160
Um this idea of like go after a directory and then deep research or deep analyze uh or deep process in some way recursively uh inside that is is another example

s207
00:20:29.160 --> 00:20:30.640
uh I have here.

s208
00:20:30.640 --> 00:20:44.880
You can do audits, uh bug sweeps, you can do adversarial things such as having a skeptical agent or um you know, a red team uh set of agents uh that are going to

s209
00:20:44.880 --> 00:20:51.600
uh try to uh improve the system adversarially or in parallel.

s210
00:20:51.600 --> 00:20:59.120
And then uh one really cool thing that you can do with Open Pros that I just added recently is kind of goes back to my very first slide, right?

s211
00:20:59.120 --> 00:21:10.600
So, like one day I get this amazing result, the next day they trade away all my all my uh crypto currency, which is very small, thankfully.

s212
00:21:10.600 --> 00:21:15.480
Um, but like, how do we get these things to be more reliable?

s213
00:21:15.480 --> 00:21:21.040
And how do we get them, you know, we we have like a golden session and we have a great day.

s214
00:21:21.040 --> 00:21:23.200
And now we want to capture that and use it over and over again.

s215
00:21:23.200 --> 00:21:29.120
So, I built a system where you can take a golden session for Cloud Code, Codex Pi, whatever you want.

s216
00:21:29.120 --> 00:21:40.680
And it's a Prose program that will actually have the agent deconstruct that session and turn it into a reusable Prose workflow, um, that again can involve this idea of recursive

s217
00:21:40.680 --> 00:21:50.520
coding agents, um, to get you to a reliable, uh, way of getting to that golden state of performance over and over and over again.

s218
00:21:50.720 --> 00:21:55.080
Recursion Recursive coding agents for the win.

s219
00:21:55.080 --> 00:21:57.640
I really think this is very powerful.

s220
00:21:57.640 --> 00:22:00.280
RLMs just kind of blew my mind when they first came out.

s221
00:22:00.280 --> 00:22:08.160
And again, as you can probably see through this talk, I've been absolutely obsessed with applying the ideas of RLMs to coding agents.

s222
00:22:08.160 --> 00:22:12.920
The three things that I hope you'll take away from this is one, like, trust is reliability.

s223
00:22:12.920 --> 00:22:16.840
Like, how can we how can we trust something that isn't reliable?

s224
00:22:16.840 --> 00:22:26.720
And again, my argument and this idea of the mismanaged genius is um, that the next step is not, um, more raw intelligence.

s225
00:22:26.720 --> 00:22:28.600
It's actually, uh, behavioral.

s226
00:22:28.600 --> 00:22:31.440
It's actually orchestration.

s227
00:22:31.440 --> 00:22:43.920
I personally believe that, um, RLMs represent this new paradigm of test time compute, inference time compute, uh, where tool calling and reasoning are unified.

s228
00:22:43.920 --> 00:22:48.720
And we reason through tool calling and we can, uh, recursively iterate.

s229
00:22:48.720 --> 00:22:57.600
And one of those tools is to call another agent to go do it on some other specific task or subset of the problem.

s230
00:22:57.600 --> 00:23:06.280
Uh, and then also, I hope we settle a little bit of this drama around like wait, like are are LLMs actually new?

s231
00:23:06.280 --> 00:23:07.720
Aren't they just coding agents?

s232
00:23:07.720 --> 00:23:09.840
Yes, coding agents can be LLMs.

s233
00:23:09.840 --> 00:23:12.920
They aren't automatically LLMs.

s234
00:23:12.920 --> 00:23:22.960
And so I've showed a couple of different Claude code dynamic workflows that can turn Claude code into an LLM as well as some ways of doing this with open pros

s235
00:23:22.960 --> 00:23:25.640
that you can use with any coding agent.

s236
00:23:25.640 --> 00:23:31.840
So, I see this as an incredibly powerful way of working with coding agents.

s237
00:23:31.840 --> 00:23:36.280
I hope you will dig in more to recursivecodingagents.com.

s238
00:23:37.200 --> 00:23:40.440
But, with great power comes great responsibility.

s239
00:23:40.440 --> 00:23:45.960
So, until next time, please recurse responsibly.

s240
00:23:45.960 --> 00:23:48.360
Thank you very much.