311 - Self learning harnesses are here

Kaushik Gopal (0:04)

Welcome back to a new season of Fragmented. Every 10 episodes, we pause, learn, and try 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, there's 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.

On that note, on 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, Claude Code and Codex 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, but 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 on to Pi. What's your take between OpenCode and Pi and where the agent harnesses are today?

Yuri (1:21)

So I think the main thing with Pi is just, it's kind of like NeoVM. 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 let you do basically anything. Like 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. So even the UI itself, you can customize. So it's really, really open to extension.

Kaushik Gopal (1:54)

I think that was the thing that convinced me, because even OpenCode has the idea of plugins, but I couldn't necessarily change all aspects of the UI that easily, but Py allows to do that as well.

Yuri (2:05)

I think OpenCode also is getting into this idea of being more extensible, but the whole idea of Py was that from the very beginning. And 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, like DeepSeek Harness, I think that's one of the main ideas behind it. Can you tell us why do you think DeepSeek Harness is so interesting?

Kaushik Gopal (2:28)

So DeepSeek Harness was released in developer preview and it's completely open source, so very recent. After its release, even the authors of both OpenCode and Py have said there's really interesting ideas in this harness that they themselves want to bring back to Py and OpenCode. But I don't think anyone has tried to articulate that difference in a simple way, so we're going to try and do just that. So what DeepSeek Harness does is they use the same philosophy of Py, which is that you have a minimal agent core and then you have extensions on top of it. But DeepSeek Harness takes that idea to the logical extreme. So they 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, right? Because if you think about an event bus of plugins, it can get really chaotic, right? Because how do you manage the dependencies between them? They might fire at different times. What happens if one instruction overwrites the other? That kind of stuff.

Yuri (4:11)

Yeah, but then again, this still sounds very familiar to buy, right?

Kaushik Gopal (4:14)

Yeah, and that's initially what I thought too, right? But I think the difference is what DeepSeek's Harness does is it allows you to control things that Pi actually handles at the agent code level. So maybe let me give you an example that makes it simpler to understand. DeepSeek 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 code level. So in Pi, you don't get to control that. You get to write extensions to control things around it. DeepSeek 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 core disk kernel, and you can even control that agent loop. So for example, if you want to build the URI Harness, which 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, DeepSeek Harness allows you to do that by just registering a plugin that handles the agent loop.