311 - Self learning harnesses are here

0:00Welcome back to a new season of Fragmented. Every 10 episodes, we pause, learn and cry something a little different with the podcast. So, for this season, Yuri and I decided we're going to do really short and crisp episodes. In this world of AI, this is so much changing and so much to talk about. So we're going to make these short and crisp and get right to the point. That note, hard to the show. So Yuri, most of the step function improvements in AI engineering that we have seen come through at the model layer. More recent developments and interesting things that are changing the game are coming actually from the harness level. For the longest time, Cloud Code and Quatics have been the mainstay and you assume they work a certain way. You make certain tweaks to the harness to enable the model and that's how we have thought about all of this. There's also extremely popular open source harnesses like OpenCode and Pi.

1:03But there's two new entries in the field that are really changing the game. People are almost considering this to be the frontier of AI engineering. I've used and loved OpenCode in the past, but you were the one that got me onto Pi. What's your take between OpenCode and Pi and where the agent harnesses are today? I think the main thing with Pi is just it's kind of like new of him. Very minimal when you install it, it doesn't have a lot of features and you can just build it the way you want it. I think that Pi makes it so much nicer to customize. Since it's very minimal, the extension points that they give you that you do basically anything. You can change how compaction works or you can build any sort of workflow that you have in mind and you can get into the harness. Even the UI itself, you can customize. It's really open to extension. I think that was the thing that convinced me because OpenCode has the idea of plugins. But I couldn't necessarily change all aspects of the UI that easily. But Pi allows to do that as well.

2:05I think OpenCode also is getting into this idea of being more extensible. But the whole idea of Pi was that from the very beginning. I think a lot of people are catching up on that and seeing that this is a good idea. And this new one that we're going to talk about, deep-seek harness. I think that's one of the main ideas behind it. Can you tell us why deep-seek harness is so interesting? Deep-seek harness was released in developer preview and it's completely open-source. Very recent. After its release, even the authors of both OpenCode and Pi have said this really interesting ideas in this harness that they themselves want to bring back to Pi and OpenCode. But I don't think anyone has tried to articulate that difference in a simple way. So we're going to try to adjust that. So what deep-seek harness does is they use the same philosophy of Pi, which is that you have a minimal agent core and then you have extensions on top of it. But deep-seek harness takes that idea to the logical extreme.

3:05They basically take that core and they make it as tiny as possible, as minimal as possible. They call that core, the kernel, and this tiny kernel is called the cordus kernel. The only job of this cordus kernel is to mount and unmount plugins. Manage the dependencies between these plugins and everything else that you expect from your agent harness, like tool calls, the models being used, the sessions, the sandbox handling, storage, the loop mechanics, the scheduling, even the UI itself. Literally everything they treat as a plugin. In fact, if you look at the blog post where they released it, that's the tagline, everything is a plugin. So they really mean it. So you can think of this cordus kernel as this small runtime that manages an event bus of plugins. And it's no small order, because if you think about an event bus of plugins, it can get really chaotic. Because how do you manage the dependencies between them?

4:05They might fire at different times. What happens if one instruction overrides the other? That kind of stuff. Yeah, but then again, this still sounds very familiar to buy, right? Yeah, and that's initially what I thought too, right? But I think the difference is what deep seeks harness does is it allows you to control things that Pi actually handles at the agent cord level. So maybe let me give you an example that makes it simpler to understand. Deep seek harness allows you to control the agent loop mechanics itself. So if you've seen the typical thing, you have a user prompt, it makes the model call. You might have some reasoning mechanisms. It might issue more tool calls. And that loop of how to function is handled at the agent cord level. So in Pi, you don't get to control that. You get to write extensions to control things around it. Deep seek takes it to a whole new level. They're like, well, you want to control the agent loop itself. Well, just write a plugin and then register that plugin to the cordus kernel. And you can even control that agent loop. So for example, if you want to build the urethrness, which I don't know,

5:06it's every second message or every third message is only when you want to respond. You can do that. I don't know why you would ever build something like this. But if you did, deep seek harness allows you to do that. We're just registering a plugin that handles the agent loop. I wonder if this plugin system they have is also allowing for live updates on how the harness works. Because for example, I know that with Pi, you can code a new extension and you just reload. How does that work there? They actually do it one better. So you know with Pi, you can code up a new extension. You just hit slash reload and it's super convenient. It loads it up. But it's technically not in real time. Because what's happening is that you're reloading the entire session and because of how lllm's work, you're resuming the session. With deep seek harness, they have this mode called creative mode. This is the futuristic part about the whole harness itself. It inspects its current runtime. It can instantiate and test cordus plugins in memory. It can compose them together and create an entirely almost new agent run in the next loop.

6:09And it does all of this in runtime. And the even crazier part is this means you can basically do this even with our user prompt. So it's not like you're writing code on the side building and then doing it. You can literally prompt the agent to do this. And deep seek harness itself will create the plugin, test the dependencies and do it in the next run. This is truly the crazy part that I think is moving and pushing the boundaries in terms of where we're going with this. But you've been following pretty closely another development on this front. There's another harness that I think you pointed out that's doing something similar. Can you talk about that? Yes, so I think it's all about this idea of self-improving harnesses. You can see as you're going through a session that something could be better and you can change during runtime and it just improves. Yeah, and this concept of self-improving is interesting because there have been agent harnesses in the past that pitched this as their big differentiating feature, right? Like Hermes and even OpenClaw for that matter.

7:10So I think Hermes and OpenClaw, they're very much trying to cater to this audience, which is like the more you use it, the more it learns from how you use it. And then it tries to generate memories and tries to create some skills to better achieve what you were trying to achieve on a past run. So I think what they try to do is to codify these things. It's not something fundamentally new. It's just that they do it proactively. I think that's the big point. When you said codify it, they codify it in the form of agent skills and these memory markdown files, which to your point, again, it's not necessarily new, but it's proactively doing that for you for the next one. That makes a lot of sense. So what's this new agent? Yeah. So this new one is a mouthful because it brings a lot of weird words again. It's called Prime Agent and it's an RLM-based harness. And what does RLM again remind me like reinforcement learning, right? Yeah. So that's the thing. It's not it's not that. It's not the RL from reinforcement learning.

8:15This is like a recursive language model, but it's not also not a model to be honest. Oh, wait. What? It's yeah, there's a paper about it. They kind of try to justify the whole naming thing. But from a high level, these guys are doing two things. They bring these two new abstractions. This RLM and this idea of continual harness, it goes on for, I don't know, long horizon basically. So it's just this abstraction literally a way to use a harness. And the idea is that the context and the subagents delegation, they're all treated like function calls and variables. And these all works because these abstractions, there are something that the agent can call inside a REPL, which is literally a Python kernel, which is the same thing that you use for Jupiter, for example. So just imagine that you have this Python environment, which enables the agent to call a subagent, like the instantiators of agents, just like a live function call on this magic notebook that the

9:18agent has access to. It also is very complicated, but from a very high level, it's basically that's just this REPL is there only two other standard harness features, which you know, like skills and what not, they're called as functions in this kernel. Interesting. So help me understand technically with pie and all these agent harnesses. Don't they also internally have function calls, because if you look at the agent core for pie or even this newer deep sea harness, I mean, there are functions in between and I can call those functions, right? Well, what makes this different? I feel there's something else that I'm not getting. Right. Yeah. So I think the main difference that here they have this other concept, which is called container harness, which is basically a persistent environment in which the agents can create, read, update, delete, you know, like, throw the operations on things like skills, memories, and subagents. Interesting. So you can dynamically do these things in memory, basically. And this lets the agents, you know, contribute to the harness states while the work is being done. So

10:22I think a good mental model for all this is just like when Cloud Code introduced like something they call PTC, which is programmatic tool calling instead of calling a tool and getting the result and then calling another tool and getting the result like the agent can think ahead and just spawn small environment where it can just do a bunch of two calls and get the result. For example, like if you want to do some data analysis, you can do all the data analysis with a script, you know, you just create this ripple environment and you just run a bunch of things and you try a few things and you just get the result out. So you don't pollute the the context. So it's kind of like the same idea, but now and that's the recursive part. Now you can do that for the whole thing. So when you get a task, the agent can break down the task dynamically and launch these subagents, which are also function calls, which are also doing the same thing, which is like, there are also instances of themselves, right? So you launching a bunch of subagents. It's almost like the number of functions

11:23is limited, which is the current operation. But then they have taken these concepts from the harness and made them as like variables and they've added semantics to it, right? You can crud on top of all of those things in some ways. Yeah, and because of the since this is running memory and they they do some crazy tricks, which is like trying to improve the setup to know the harness as they the task is being executed. So I think the main application for this is like what they call long horizon tasks, which is something that goes on for longer, you know, and and that's that's one of the main applications. Is this something we can start using now? Yeah, it's actually available. It's open source. You can try is just just something very very fresh, I would say. All of this is obviously extremely new, but I think the conclusion is so far a lot of the AI labs have pushed the limits in terms of what these models can do and that will continue to a large extent. But there's also this interesting new world that's manifesting to this side, which is people

12:27want to innovate more even at the harness level. Self-learning harnesses feels like that next big thing.