Transcription: OpenAgents Episode 207 - Your Keys, Your Coins, Your Identity

Source: https://x.com/OpenAgentsInc/status/2016423268564001059 Wiki source: https://raw.githubusercontent.com/wiki/OpenAgentsInc/openagents/Video-Series.md Media title: OpenAgents - Episode 207: Your Keys, Your Coins, Your Identity We explain how Aut... Upload date: 20260128 Transcription model: gpt-4o-transcribe-diarize Generated at: 2026-06-01T02:26:55Z

Machine-generated transcript. Review speaker labels and wording before using this as quote-grade source material.

[00:00] Christopher David: Autopilot desktop app,

[00:02] Christopher David: very first alpha build.

[00:04] Christopher David: Let's check it out.

[00:07] Christopher David: So autopilot begins kind of as a UI for codecs, the best long-running coding agent at the moment.

[00:16] Christopher David: But it's got one key addition. On the right sidebar here,

[00:20] Christopher David: you'll see something called full auto.

[00:22] Christopher David: And when I enable that and chat.

[00:27] Christopher David: At the end of a turn, instead of it stopping,

[00:32] Christopher David: or instead of going with the next thing that you've queued up, it's going to intelligently select the next action using a new agentic primitive we're calling Guidance Module,

[00:43] Christopher David: and we're going to step through that.

[00:45] Christopher David: Let's compare it a little bit to what people are doing right now with Ralph and stuff.

[00:50] Christopher David: So how I and a bunch of people who use Codex right now.

[00:54] Christopher David: uh you know we queue up something maybe give it a big refactoring task sometimes it can take up to 20 30 minutes or 45 minutes it can really do great kind of long running tasks

[01:06] Christopher David: but when it finishes a chunk of work it'll say you know here's my summary i'm done and if you want to like go afk for a while you can queue up different messages which might be do something else or it might be continue if you give it a big thing continue continue continue

[01:24] Christopher David: So that's good.

[01:25] Christopher David: Codex spits out very reliable stuff,

[01:28] Christopher David: usually.

[01:29] Christopher David: More reliable than cod code I've found.

[01:31] Christopher David: But then you've got the Ralph loop, which aims to remove the human from the loop and replace it with this sort of dumb,

[01:40] Christopher David: a.k.a. Ralph.

[01:43] Christopher David: It just does the next box on the checklist, and hopefully you've kind of specked that out.

[01:49] Christopher David: And it just kind of like dumbly goes through and does each PRD checkbox until hopefully you have something usable at the end of that process.

[01:59] Christopher David: So we're going to kind of take a little bit of the thoughts of both of these and kind of keep going with this idea of yes, we want to remove the human from the loop, but we want to add more intelligence than just going down.

[02:14] Christopher David: A list.

[02:15] Christopher David: Maybe something happened.

[02:18] Christopher David: Maybe you got rate limited on one of your accounts.

[02:22] Christopher David: Maybe some new information came up. Maybe there's a new plug-in that just got discovered that's doing what you're trying to do better.

[02:28] Christopher David: We want there to be some intelligence between these turns.

[02:32] Christopher David: So we're introducing this new primitive called a guidance module.

[02:38] Christopher David: And we've got a little...

[02:40] Christopher David: Dot kind of specking this out.

[02:42] Christopher David: All this is open source.

[02:43] Christopher David: All this will be

[02:45] Christopher David: You know improved upon gradually if you're watching this

[02:48] Christopher David: After January 26 2026 it will be better and stuff by the time that you're looking at Okay,

[02:55] Christopher David: let's step through this so turn to turn guidance module The purpose is to describe the intelligence layer that runs between codex turn

[03:01] Christopher David: inside a full auto run calling this full auto

[03:05] Christopher David: for autopilot. And we're doing codecs for now just because it's the best coding agent. It's a good thing to start with. It's open source.

[03:13] Christopher David: But this should be able to be worked with multiple different agents.

[03:19] Christopher David: We're going to start with codecs first.

[03:20] Christopher David: So it replaces the manual continual loop with a structured, extensible guidance module that can be evaluated and improved over time.

[03:27] Christopher David: So for the definitions,

[03:28] Christopher David: turn is one codex execution window ending a turn completed,

[03:32] Christopher David: that's the like session that lasts for 30 minutes or five minutes or however long in the context of a thread or session.

[03:40] Christopher David: A run is a multi-turn session,

[03:42] Christopher David: blah blah blah, composed of turns.

[03:43] Christopher David: Guidance is a soft recommendation for what to do next.

[03:46] Christopher David: Guardrails are hard,

[03:47] Christopher David: deterministic constraints that could override guidance.

[03:52] Christopher David: Okay,

[03:52] Christopher David: so today long-running code excerpts are driven by a manual loop.

[03:55] Christopher David: You issue a run, then type continue or queue if you want prompts. Turns are not aware of each other beyond ad hoc file handoff.

[04:01] Christopher David: You're kind of reading and writing to markdown docs, which is like okay.

[04:05] Christopher David: There's no shared model of state,

[04:07] Christopher David: budget,

[04:07] Christopher David: or environment across turns.

[04:09] Christopher David: This is brittle and does not scale.

[04:11] Christopher David: The system needs a real decision engine between turns that can see the full context of what happened in the last turn,

[04:16] Christopher David: understand the goal,

[04:18] Christopher David: constraints,

[04:19] Christopher David: environment, and remaining...

[04:20] Christopher David: meaning budget decide the next action with measurable confidence improve over time via evals and community contribution as well as maybe pull in plugins or tools from third-party registries there's all sorts of ways to kind of like add extensibility into that decision process so whereas before the human is the scheduler you're or the planner or you're prompting it to make a plan and then do it and then keeping it on task or you're delegating to this kind of like dumb loop

[04:48] Christopher David: uh afterwards you're we're kind of putting more agency and trust into the guidance module improving the autonomy blah blah blah all right key idea replace the continue step with a dspie powered guidance module so in terms of like asian architectures the um uh framework i don't even know what you call it dspie maps perfectly to this

[05:14] Christopher David: Uh,

[05:15] Christopher David: DSPy stands for Declarative Self-Improving Python.

[05:18] Christopher David: We're not doing this in Python,

[05:19] Christopher David: we're doing it in Rust,

[05:20] Christopher David: but there's a Rust version of this same library called,

[05:23] Christopher David: um,

[05:24] Christopher David: DSRs. And just the,

[05:26] Christopher David: like, super fast introduction to what DSPy is and why people like it,

[05:30] Christopher David: uh,

[05:31] Christopher David: it's a way to build AI behavior like you build software with clear interfaces and composable parts instead of one giant prompt. Uh,

[05:37] Christopher David: the two main concepts to know from that are signature and module.

[05:41] Christopher David: A signature is just a typed contract for an AI step,

[05:45] Christopher David: what you give it and what you expect back.

[05:48] Christopher David: Example, given the goal and what happened last turn and maybe budget constraints or whatever,

[05:54] Christopher David: return the next action,

[05:55] Christopher David: a reason and a confidence score.

[05:58] Christopher David: Confidence score is cool because if it's got very low confidence,

[06:01] Christopher David: you can say,

[06:01] Christopher David: okay, if you don't really know what should be done next, then just wait.

[06:06] Christopher David: or consult some other agent. And then a module is a small program made out of one or more signatures.

[06:11] Christopher David: It can call other modules,

[06:13] Christopher David: combine results,

[06:14] Christopher David: and enforce structure.

[06:15] Christopher David: Example, a next action selector module that reads the turn summary,

[06:19] Christopher David: checks budget,

[06:20] Christopher David: and outputs whether to continue,

[06:21] Christopher David: pause,

[06:21] Christopher David: or stop.

[06:22] Christopher David: So you can bundle a bunch of the different signatures into modules.

[06:26] Christopher David: It's all composable.

[06:27] Christopher David: The punchline is that signatures make AI steps reusable and comparable,

[06:31] Christopher David: and modules let you snap those steps together into a bigger system and then optimize them with...

[06:37] Christopher David: With evals instead of hand tuning prompts forever.

[06:41] Christopher David: There's a whole kind of evaluation and optimization algorithm,

[06:45] Christopher David: I think called MIPRO V2,

[06:47] Christopher David: that goes along with this so you can have these things just basically improve over time.

[06:54] Christopher David: Okay,

[06:55] Christopher David: let's step back to this.

[06:58] Christopher David: So the guidance module is a composable stack of DSPI signatures and modules plus policy gates,

[07:05] Christopher David: state,

[07:05] Christopher David: and optimization.

[07:06] Christopher David: Because these are all reusable and composable,

[07:10] Christopher David: we can do some very interesting things with combining this with open source and market incentives.

[07:20] Christopher David: So, once the decision layer is expressed as declarative signatures (clear input-output contracts), it stops being a one-off blob of prompts and becomes a packaged surface. This is the same move JavaScript made with NPM.

[07:35] Christopher David: Before NPM, teams hand-wrote ad hoc utilities inside each repo,

[07:39] Christopher David: improvements stayed trapped in-house.

[07:41] Christopher David: After NPM,

[07:42] Christopher David: small modules with stable APIs became reusable,

[07:45] Christopher David: searchable,

[07:45] Christopher David: and composable; an ecosystem flourished because anyone could improve one piece and everyone could adopt it.

[07:51] Christopher David: We're starting to have some of that now,

[07:53] Christopher David: people like, you know, copy pasting each other's prompts or like skills are starting to become kind of discoverable pieces,

[08:01] Christopher David: but it's still very clunky.

[08:02] Christopher David: but just this idea of it being composable it can be pulled in you can compose your agentic flow out of a bunch of these different small pieces so with signatures each capability becomes a drop-in package budget policy stop decide or next action selector verifier independently discoverable evaluated and upgradable and monetizable by the way more on that shortly signatures turn agent intelligence into an API

[08:30] Christopher David: Once intelligence has an API it can have packages like NPM so the ecosystem can flourish. Small composable module discoverable by anyone,

[08:37] Christopher David: improved by anyone,

[08:38] Christopher David: and monetizable by the people who ship real games.

[08:42] Christopher David: We want a system that is not just open source but extensible and packaged.

[08:47] Christopher David: Each policy or selector can be shipped as a package. Each package ships with evals and measurable gains. The runtime can load compare and route between packages.

[08:56] Christopher David: Contributors can improve a single piece and get credited or awarded.

[08:59] Christopher David: Think NPM,

[09:01] Christopher David: but for agent intelligence,

[09:02] Christopher David: signatures,

[09:02] Christopher David: module, and policies. Yeah, so right now you've got people trusting teams,

[09:06] Christopher David: like you're trusting the codex team or the Claude code team or the AMP team to like improve their harness,

[09:14] Christopher David: right?

[09:15] Christopher David: Or you're trusting the Ralph team and some of those teams that are open source.

[09:21] Christopher David: Open code Ralph may improve faster than the closed sourced ones do,

[09:25] Christopher David: but it's still kind of bottlenecked by like what is that one team going to do for their algorithm and their harness.

[09:33] Christopher David: This is, we think,

[09:35] Christopher David: the next phase of that,

[09:36] Christopher David: to subject it to true like open market forces.

[09:40] Christopher David: You'll just get a lot more innovation and improvements in that way.

[09:46] Christopher David: So just a little spiel on how this kind of ties into our broader vision.

[09:50] Christopher David: So this guidance module is the bridge between autonomy and the open agents market.

[09:55] Christopher David: It turns between turn decisions into typed audible work units that can be routed, verified and paid for. Why this matters.

[10:04] Christopher David: So tying this into our sort of like compute fracking idea of you've got a bunch of spare compute that's on people's computers that they aren't using in part because everyone's just paying anthropic for their tokens because all of the harnesses only use their own models. Whereas you've got all this untapped compute that's on your device that could be used like it's the ideal type of compute to be used with some of these jobs where things are being broken up into a bunch of small pieces.

[10:31] Christopher David: This is go check out our recursive language models videos a couple of videos ago where we talk more about how that's an ideal algorithm that also is from the founders of D_S_P_I_

[10:45] Christopher David: Uh anyway, there's a lot of pieces that we're pulling together here. Um we'll I think spend a couple more

[10:52] Christopher David: videos going into individual pieces of some of this. Um but the big idea here is that

[10:58] Christopher David: We are releasing a single desktop app that has the whole kind of cycle of it's a way to have a coding agent that is, you know, a local coding agent starting with codex increasingly augmented with local compute yours and others if you want to be able to throw out a job to like a hundred different like micro jobs that will all be kind of.

[11:24] Christopher David: um possible through our swarm compute all of which is going to be built into this autopilot binary so the stuff that we did a couple videos ago about our pylons all that's going to be folded into this one binary to keep things simple this autopilot binary is also going to have a bitcoin wallet so the kinds of things that you're doing when you are paying codex to do cool stuff maybe you want to be able to sell some of that data

[11:53] Christopher David: to other people because you discover some gotcha that instead of someone else spending you know an hour or 10 minutes with their agent burning their compute maybe they just want to pay you three cents and save that time so yeah all sorts of stuff is going to open up here but the general idea is that we want you to be able to code on autopilot

[12:19] Christopher David: Sell some of your Compute or Agentic Compute on autopilot if you want to earn some money streamed to your wallet here.

[12:28] Christopher David: We're going to turn Compute into software,

[12:34] Christopher David: software into business value that gets priced and sold in Bitcoin.

[12:43] Christopher David: There's a lot here, folks.

[12:45] Christopher David: We'll do another video tomorrow.

[12:47] Christopher David: See you soon.

[12:48] Christopher David: So that's the coding agent architecture. Now how will users and agents communicate and pay each other to build this into a network? Well, through public key cryptography. This is explained on our new doc site under Identity and Wallet on the left.

[13:09] Christopher David: There are a few keys you can see here.

[13:14] Christopher David: These are the relevant keys.

[13:18] Christopher David: These will be generated in the autopilot desktop app. There will be a key pair generated automatically for you when you open the app for the first time, and you can regenerate them like this very easily. And let's tell you what these are. So we've got the Noster public key,

[13:36] Christopher David: Noster secret key,

[13:38] Christopher David: Spark public key,

[13:39] Christopher David: and seed phrase.

[13:42] Christopher David: The ones that are relevant, the most relevant thing here to remember and write down is the seed phrase.

[13:51] Christopher David: This will begin,

[13:52] Christopher David: will kind of like be storing this in a secure place on your computer,

[13:56] Christopher David: but you'll be able to see that and write this down.

[14:00] Christopher David: With this seed phrase, we can derive your Spark public key and your Noster public key. So Noster,

[14:08] Christopher David: think.

[14:10] Christopher David: identity think you've got a decentralized data network free

[14:20] Christopher David: and global market of relays that you have access to and that key pair will attach any identity data you want to it you can connect the social account you can be anonymous it doesn't matter you can put up a avatar that all goes to your nostril key pair

[14:36] Christopher David: And then Spark is a Bitcoin layer two from

[14:43] Christopher David: a great company called Lightspark, and it's just a way of reliably transferring Bitcoin instantly and essentially freely anywhere in the world built on top of the Lightning Network.

[15:00] Christopher David: So if there is a SPARC public key that you know someone else's SPARC public key,

[15:06] Christopher David: you can just send them money instantly.

[15:10] Christopher David: The Nostro secret key, this is derived from the seed phrase.

[15:14] Christopher David: It's used for signing messages.

[15:15] Christopher David: You don't really need to remember that.

[15:18] Christopher David: The seed phrase is what you'll need to write down.

[15:21] Christopher David: This is a thing that you'll never want to share.

[15:24] Christopher David: You've got to keep this safe.

[15:25] Christopher David: um note also that this is what we call a hot wallet setup um this is not set up for you to store large amounts of bitcoin really this is like a hot wallet so ideally you can load a few dollars of bitcoin here or ideally you're not loading anything and you're just earning but when you earn ten dollars fifty dollars hundred dollars

[15:47] Christopher David: more than you'll want to spend on Compute or Agents or whatever,

[15:51] Christopher David: you'll want to sweep that out to a more secure wallet,

[15:55] Christopher David: which we will not be running, but you'll use something like,

[16:00] Christopher David: well,

[16:01] Christopher David: any of the great wallets that are out there.

[16:02] Christopher David: Okay,

[16:03] Christopher David: this is documented on our website,

[16:06] Christopher David: our docs site,

[16:08] Christopher David: and let's keep it simple, people.

[16:13] Christopher David: There's a lot of kind of bullshit out there in crypto land and we're gonna make it real easy for you to transact and do stuff in autopilot and when you'd have a little crash course on that before we begin.

[16:27] Christopher David: See ya.