Transcription: OpenAgents Episode 255 - FastFollow: Building Agent Parity
July 17, 2026 · View on GitHub
Media source: OpenAgents FastFollow_ Building Agent Parity.mp4
Source trim: 00:00:38 to end
Transcript runtime: 01:11:25.63
Transcription model: gpt-4o-transcribe-diarize
Generated at: 2026-07-16
Machine-generated transcript, reviewed for obvious product names and technical terms. Verify wording against the video before using it as quote-grade source material.
[00:01] Christopher David: Well, this video is going to piss some people off, but I don't care because we
[00:06] Audio note: [Audio cuts out. The HD video displays "THE HOUR IS LATE" with smaller text reading "wtf Loom".]
[00:13] Christopher David: need team open to win.
[00:17] Christopher David: We need...
[00:19] Christopher David: Speaking as an American,
[00:21] Christopher David: Team America to win.
[00:22] Christopher David: Well, we need America to win in the open way,
[00:26] Christopher David: not in the we're scaring politicians into building moats that put Chris out of business and otherwise entrench AI singletons.
[00:45] Christopher David: Bad, bad, bad, bad, bad.
[00:47] Christopher David: Okay,
[00:47] Christopher David: so we're going to take full advantage of how good coding agents are these days and our open sourceiness.
[00:59] Christopher David: 100% of all code that we ship is open source on our GitHub repo.
[01:08] Christopher David: We also have a lovely folder we're going to be working with in this video called docs/teardowns where we've had our agents do analysis of various projects,
[01:23] Christopher David: some of which were open source,
[01:25] Christopher David: some of which are partially open source,
[01:26] Christopher David: some of which are closed source,
[01:28] Christopher David: some of which had leaked source,
[01:30] Christopher David: like whatever we could get our hands on, like agents.
[01:35] Christopher David: Learn what you can from these things.
[01:38] Christopher David: Throw some analysis into here.
[01:40] Christopher David: Like for example, hey Claude Code.
[01:47] Christopher David: Let's throw the Claude Desktop app teardown. Like you can learn a lot by looking at the Electron bundles of apps.
[01:54] Christopher David: The closed source binaries closed source projects you can learn a lot from.
[02:01] Christopher David: peeling apart minified code and I don't
[02:09] Christopher David: feel bad about it at all so here's
[02:15] Christopher David: kind of the idea though we want to have our agent get to parity with the best agents that are out there
[02:22] Christopher David: And then layer on all of the other cool stuff that makes OpenAgents special,
[02:26] Christopher David: all the economic layers,
[02:28] Christopher David: the network layers,
[02:29] Christopher David: comms layers,
[02:30] Christopher David: gamification layers,
[02:32] Christopher David: all the stuff that we've been building over how many episodes now?
[02:36] Christopher David: 254 episodes over almost three years. People,
[02:40] Christopher David: for those just tuning in,
[02:44] Christopher David: OpenAgents is building the best agents,
[02:48] Christopher David: period.
[02:49] Christopher David: Guaranteed. It's in the name.
[02:50] Christopher David: OpenAgents.
[02:51] Christopher David: What do you want?
[02:52] Christopher David: Closed agents?
[02:53] Christopher David: No.
[02:53] Christopher David: You want OpenAgents.
[02:57] Christopher David: You know, for those just tuning in, you know, check out our episode 200. You can kind of read about themes and the network power and things like that. And I can just tell you for our friends who are also running like coding agent companies like OpenAgents is going to have the best coding agent.
[03:14] Christopher David: We're going to have the best every agent.
[03:19] Christopher David: I've been trying to explain this over 200 plus videos,
[03:21] Christopher David: but let me see if I can summarize it. OpenAgents is the only company figuring out how to apply network effect to AI models and products.
[03:36] Christopher David: and you don't see this or if you've been paying attention you don't take it seriously yet because we've been standing on an exponential that seems very linear and you don't know who the hell I am and I'm just some random asshole with a Twitter channel that's not very big all right yeah who am I but you'll see you'll see very soon
[04:03] Christopher David: So OpenAgents is we just have the best agents.
[04:06] Christopher David: Now,
[04:06] Christopher David: there will be some amount of, I don't know, fighting or pushback to OpenAgents. Everyone's got their little,
[04:12] Christopher David: you know, you raised your Series B and you got to raise your Series C and your valuation's got to go up and you got to fight off the new guy.
[04:21] Christopher David: That's fine. That'll make for good, you know, get your popcorn.
[04:29] Christopher David: But the thing is that we're aggregating network effect.
[04:32] Christopher David: And the sooner you join the network effect that we are aggregating, the sooner you go benefit.
[04:42] Christopher David: Because we've taken great care to align ourselves with certain trends in
[04:49] Christopher David: Bitcoin,
[04:51] Christopher David: in open protocols, in who's doing what,
[04:54] Christopher David: and we've been fleshing a lot of this out.
[04:59] Christopher David: Throwing a lot of stuff at the wall.
[05:00] Christopher David: Not all of it sticks,
[05:02] Christopher David: but a bunch of it did.
[05:05] Christopher David: And that's just my long-winded intro to tee up a new mode.
[05:12] Christopher David: And we're going to brainstorm it fully using OpenAgents Desktop in this video.
[05:22] Christopher David: You can see it's currently working on...
[05:27] Christopher David: Taking the look see through amps binary.
[05:29] Christopher David: What's up amp?
[05:31] Christopher David: A closed,
[05:33] Christopher David: bun compiled,
[05:34] Christopher David: TypeScript JavaScript system whose durable unit is a cloud-backed actor thread,
[05:38] Christopher David: projected into CLI web mobile and remote runners.
[05:41] Christopher David: The compelling seam is across model orchestration over durable,
[05:44] Christopher David: searchable work history.
[05:45] Christopher David: The strongest negative evidence is concrete too.
[05:47] Christopher David: Local tools run without approval by default. Hey, I like that actually.
[05:51] Christopher David: Core source is unavailable,
[05:52] Christopher David: more or less, and the direct installer verifies the same origin checksum while release signing is disabled.
[05:57] Christopher David: The installed macOS binary fails Apple signature verification.
[06:03] Christopher David: Okay.
[06:05] Christopher David: So, you know, we have – if your project is in our teardown's folder,
[06:10] Christopher David: it's because we respect your project enough to want to, like, learn from it.
[06:14] Christopher David: So we got ChatGPT. We got Claude.
[06:17] Christopher David: Codex, T3 Code,
[06:20] Christopher David: OpenCode,
[06:21] Christopher David: cursor,
[06:22] Christopher David: executor.
[06:23] Christopher David: open chamber,
[06:26] Christopher David: crab box law,
[06:29] Christopher David: Grok build command code,
[06:33] Christopher David: factory droid, and then like what we're learning from all this.
[06:38] Christopher David: Okay.
[06:42] Christopher David: What we want to do here is give customers, users of OpenAgents
[06:49] Christopher David: Desktop app.
[06:50] Christopher David: The ability,
[06:51] Christopher David: I guess I should just tell opening this.
[06:53] Christopher David: The ability to specify what projects and code bases they want their agents to learn from and programmatically keep their code base up with,
[07:07] Christopher David: whether that's feature parity,
[07:08] Christopher David: whether that's tracking and upstream with changes,
[07:11] Christopher David: taking kind of like what you want.
[07:16] Christopher David: From a code base and having your code base learn from it
[07:22] Christopher David: This is just a thing that open source developers do they keep tabs on who else is doing what they find projects to learn from and pull things in and just like that whole process canon should be
[07:34] Christopher David: Automated.
[07:35] Christopher David: All right. Let's do a new session.
[07:38] Christopher David: Let's do a new session
[07:41] Christopher David: Oh, and then while that works, we can take out the AMP Architecture Teardown, the new edition,
[07:46] Christopher David: just to give an example.
[07:48] Christopher David: Just to give an example what we got.
[08:01] Christopher David: Cool. Okay,
[08:02] Christopher David: so let's do some high reasoning.
[08:14] Christopher David: Let's design a new mode.
[08:18] Christopher David: It may or may not be a toggleable mode. Like you can look up to see how we define Full Auto.
[08:26] Christopher David: It might be a set of skills or I don't know what.
[08:32] Christopher David: We're going to call it FastFollow.
[08:40] Christopher David: FastFollow.
[08:44] Christopher David: Any project or workspace,
[08:47] Christopher David: anything that would have like an agents.md and a set of skills should also be able to define a spec of projects they want their project to FastFollow and what they want to learn from them.
[09:06] Christopher David: You can see an example of the kind of thinking behind this.
[09:11] Christopher David: In the OpenAgents slash doc slash tear downs folder where we have a list of tear downs of different projects. Some projects have more than one for projects like OpenCode, for example, where there's a lot of overlap between their architecture using Effect and multi providers and multi agents and all this stuff,
[09:35] Christopher David: a bunch of different deep dives.
[09:37] Christopher David: on their code base.
[09:39] Christopher David: And then in the OpenAgents essay,
[09:42] Christopher David: there's probably like I think a couple in there on how we want our code base to learn from these various things.
[09:53] Christopher David: We want projects to have a way of specifying those ideas of
[10:01] Christopher David: I want to learn X, Y,
[10:03] Christopher David: and Z from projects A,
[10:05] Christopher David: B, and C in whatever combination to specify that in some sort of easily machine readable deterministic predictable specification perhaps
[10:20] Christopher David: go look to see how we have defined or used
[10:28] Christopher David: ProductSpec and AssuranceSpec elsewhere in our code base.
[10:40] Christopher David: We need something like that for FastFollow.
[10:42] Christopher David: Here's what I want my product to FastFollow.
[10:45] Christopher David: You can also then go look up our Full Auto mode and you can envision that
[10:53] Christopher David: If a project ever runs out of GitHub issues or clearly outstanding next work to be done,
[11:01] Christopher David: the FastFollow spec should provide limit less work to bring our project in line with others.
[11:30] Christopher David: Review also some of what we've said about Khala,
[11:33] Christopher David: like
[11:37] Christopher David: in OpenAgents docs/transcripts, our episode called Khala Collective Intelligence and our episode about Khala Code,
[11:46] Christopher David: this idea of an orchestrator model with a blueprint system based on DSPI that can improve over time.
[11:57] Christopher David: um imagine that if there's a bunch of different companies or a bunch of different projects fast following the same projects then there's probably a lot of shared token usage so that can end up being cheap so everyone doesn't need to be running the same inference the same checks all the time opportunity to like drive costs down because there can be reuse
[12:25] Christopher David: And in fact, this idea may end up bootstrapping that Khala/bootstrap idea.
[12:31] Christopher David: Okay, I'm going to back up this note just in case, just kind of as habit for stuff
[12:42] Christopher David: breaking.
[12:45] Christopher David: Khala bootstrap.
[12:48] Christopher David: What else should I say?
[12:53] Christopher David: write a new doc slash fast
[12:58] Christopher David: follow spec or specs maybe including a ProductSpec if you want to do that and
[13:08] Christopher David: like suggested issues and such for getting her going
[13:18] Christopher David: And the first deliverable or the first test of this will be taking the projects that are in our teardown's folder and creating whatever this FastFollow spec is for the OpenAgents code base and then letting me hopefully by the end of this video or before the end of tonight a way of clicking my Full Auto button to let it do that level of analysis and such.
[13:45] Christopher David: overnight like
[13:48] Christopher David: imagine that if I've got five sub agents going I can have you know three of them working on the issues that are outstanding and then two of them doing this kind of research maybe one's doing research one's doing implementation of fast followed
[14:15] Christopher David: Is that good?
[14:19] Christopher David: You know what?
[14:20] Christopher David: I'm even going to take it up to X high.
[14:27] Christopher David: All right.
[14:28] Christopher David: So, you know, we're still tweaking our UI. I'm not happy with some things like this should not be freaking text. And, you know.
[14:40] Christopher David: I would have done a more streamlined MVP,
[14:43] Christopher David: but, you know,
[14:45] Christopher David: Claude and Codex giving us those free credits last few days is like,
[14:51] Christopher David: I gotta burn them. I gotta burn them up. Use them up while I can.
[14:55] Christopher David: Alright, let's see what we're doing here.
[14:59] Christopher David: I'll trace the existing Full Auto ProductSpec,
[15:02] Christopher David: AssuranceSpec,
[15:02] Christopher David: teardown, open data testing,
[15:04] Christopher David: and column materials first.
[15:05] Christopher David: Then I'll turn those patterns into a machine-readable FastFollow contract, an OpenAgents specific manifest seeded from the teardown catalog,
[15:13] Christopher David: and an implementation-issue slash plan that makes the overnight full-auto path concrete.
[15:19] Christopher David: I'll follow the repos in variant and publishing rules,
[15:21] Christopher David: including committing and pushing the scoped work to main.
[15:26] Christopher David: Plan.
[15:26] Christopher David: Inspect workspace.
[15:27] Christopher David: Okay,
[15:28] Christopher David: the OpenAgents contract explicitly requires bounded sub-agent fan-out for independent lanes,
[15:34] Christopher David: so I'm using it here.
[15:35] Christopher David: One read-only audit will map Full Auto plus ProductSpec and AssuranceSpec.
[15:40] Christopher David: One will inventory the teardown and essay learning targets.
[15:44] Christopher David: And one will... See, I gotta change that.
[15:47] Christopher David: I don't like jumping around there.
[15:48] Christopher David: One will extract the Khala Collective Intelligence slash Blueprint implications.
[15:53] Christopher David: I'll own the schema synthesis files,
[15:55] Christopher David: validation and publication.
[15:56] Christopher David: The audits will not edit the checkout.
[15:58] Christopher David: Cool.
[15:58] Christopher David: All right, we'll let that cook.
[16:00] Christopher David: Let's go take a look see through our amp tear down just to kind of get a sense of what we are learning from this You know, it's a closed source code base.
[16:08] Christopher David: They don't have a link to a GitHub on Their website beautiful website by the way, you know cool nice tweets nice architecture posts very nice But you know like I want it
[16:23] Christopher David: Okay, gimme it.
[16:28] Christopher David: This is a read-only architecture and product audit of the AMP CLI installed on this map,
[16:32] Christopher David: AMP's public manual and security material,
[16:34] Christopher David: its published package and SDK services, and the small amount of current public integration source.
[16:41] Christopher David: It did not blah blah blah blah blah.
[16:42] Christopher David: Okay,
[16:43] Christopher David: TLDR,
[16:44] Christopher David: AMP is no longer best understood as a terminal coding agent.
[16:47] Christopher David: It is a model-routed, cloud-backed thread system whose local CLI is both a client and an execution worker.
[16:54] Christopher David: One thread can be created or continued from the TUI, driven through cloud-compatible streaming JSON,
[17:00] Christopher David: inspected and reviewed on the web or mobile,
[17:02] Christopher David: remote-controlled while its CLI remains alive,
[17:04] Christopher David: or placed on a runner or managed orb.
[17:07] Christopher David: The current product routes different jobs through different frontier and specialist models,
[17:12] Christopher David: automatically delegates isolated subagent,
[17:15] Christopher David: and lets TypeScript plugins add tools,
[17:17] Christopher David: commands,
[17:18] Christopher David: UI modes and new agents.
[17:21] Christopher David: The installed artifact makes part of that architecture unusually visible even though the core source is closed.
[17:28] Christopher David: CLI, StreamJson, SDK,
[17:30] Christopher David: IDEBridge, WebMobile to AMP Thread and Plugin Protocols to Server Issued Thread Actor Credentials to Stateful Actor Connection over WebSocket to Local Tools and Plugins and Remote Runner Slash Orb to Routed Model and Specialist Services.
[17:48] Christopher David: The macOS executable is a Bun's channeling program.
[17:51] Christopher David: Its Mach-O contains a blah blah blah payload,
[17:54] Christopher David: large minified JavaScript bundle,
[17:57] Christopher David: rivet kit,
[17:58] Christopher David: actor,
[17:58] Christopher David: and workflow packages.
[18:00] Christopher David: You know,
[18:01] Christopher David: AMP uses rivet. Cool.
[18:04] Christopher David: News to me.
[18:05] Christopher David: WebSocket and gRPC clients.
[18:08] Christopher David: Commander,
[18:08] Christopher David: I don't know what that is.
[18:09] Christopher David: MCP, a native hearing binding telemetry update code in the CLI2UI product.
[18:14] Christopher David: The payload is inspectable, not encrypted,
[18:16] Christopher David: but it is not public source with history, blah, blah, blah, blah, blah.
[18:20] Christopher David: AMP's former public-looking repository URL returns 404.
[18:28] Christopher David: AMP's strongest product idea is the thread fabric.
[18:31] Christopher David: Let's just make sure our app is still cranking.
[18:35] Christopher David: Inspecting, studying,
[18:36] Christopher David: 33 things.
[18:40] Christopher David: It's going.
[18:44] Christopher David: A long thread remains a searchable source record,
[18:47] Christopher David: even after compaction.
[18:48] Christopher David: Other threads can reference it.
[18:50] Christopher David: Read threads searches the original history and distinguishes attempts from later outcomes.
[18:54] Christopher David: Queue, steer,
[18:55] Christopher David: and force interrupt are separate user actions, and web-mobile review deepens the same work rather than starting another chat.
[19:03] Christopher David: OpenAgents should adapt that shape. Durable work history should be remotely controllable, semantically searchable, and readable by bounded agents without flattening exact execution evidence into a summary.
[19:13] Christopher David: Its strongest negative lessons are equally concrete.
[19:18] Christopher David: AMP runs tools without asking by default I like that and recommends a policy plugin or external isolation for untrusted workspace.
[19:26] Christopher David: Permission rule I don't care. Threads are a cloud data substrate.
[19:29] Christopher David: They may retain messages,
[19:30] Christopher David: model output,
[19:32] Christopher David: tool calls and results,
[19:33] Christopher David: attachments and snippets from entire files.
[19:35] Christopher David: Workspace defaults and administrator visibility materially affect privacy.
[19:41] Christopher David: Yeah, so I think everything you do goes into their cloud.
[19:45] Christopher David: Okay, I guess that works for enough people.
[19:48] Christopher David: The same extension plane can add executable tools,
[19:51] Christopher David: lifecycle continuation,
[19:52] Christopher David: selectable modes, and sub-agents.
[19:54] Christopher David: Public types are not evidence of... Yeah, yeah,
[19:56] Christopher David: yeah.
[19:56] Christopher David: The direct installer... Okay.
[20:01] Christopher David: AMP explicitly optimizes for evolution over compatibility.
[20:05] Christopher David: In months, it has removed its editor extension,
[20:08] Christopher David: tab completion,
[20:09] Christopher David: public thread discovery,
[20:10] Christopher David: custom commands,
[20:10] Christopher David: fork to do,
[20:11] Christopher David: walk through an old bone nymphs. This can be a coherent product strategy, but it makes protocol,
[20:15] Christopher David: settings,
[20:16] Christopher David: plugins,
[20:16] Christopher David: docs,
[20:17] Christopher David: and saved work compatibility a first class risk.
[20:20] Christopher David: Core load-bearing behavior remains closed.
[20:22] Christopher David: The bundle can establish shipped client branches and dependencies.
[20:26] Christopher David: It cannot prove yada yada yada.
[20:28] Christopher David: The central OpenAgents decision is adapt AMP's durable cross surface thread fabric, semantic history reading, explicit steer/queue distinction and specialist agent composition. Reject cloud transcript authority, default open execution, opaque durability, unsigned release authority and extension driven privilege amplification.
[20:49] Christopher David: Okay. Audited artifacts.
[20:54] Christopher David: Cool, cool.
[20:56] Christopher David: Cool.
[21:11] Christopher David: Let's take a look here. The core shape is settling.
[21:15] Christopher David: FastFollow should be a standing work source contract,
[21:18] Christopher David: not a second authority mode.
[21:21] Christopher David: ProductSpec still owns what we are building,
[21:24] Christopher David: AssuranceSpec owns how claims approved, and FastFollow spec owns which up streams to study what lessons to extract,
[21:32] Christopher David: how fresh the study must be, and how to turn a gap into candidate work.
[21:37] Christopher David: The reusable unit will be a content-addressed upstream study packet.
[21:42] Christopher David: Local adaptation and implementation stay product-specific. Ooh!
[21:46] Christopher David: Study packets!
[21:48] Christopher David: Nice.
[21:50] Christopher David: All right, while that goes,
[21:51] Christopher David: let's keep learning about AMP.
[21:54] Christopher David: Product thesis,
[21:55] Christopher David: the frontier moves, the thread survives.
[21:58] Christopher David: AMP's manual names four principles. Use unconstrained token budgets,
[22:03] Christopher David: use the best available models,
[22:05] Christopher David: expose raw model power,
[22:07] Christopher David: and evolve with new models. Its product copy operationalizes those principles through four current modes,
[22:14] Christopher David: low, medium, high, and ultra,
[22:15] Christopher David: rather than a user-selected provider model matrix.
[22:18] Christopher David: The model page blah blah blah. The durable product concept is not the mode, it is the threat.
[22:24] Christopher David: Models and features can be replaced while the thread URL,
[22:28] Christopher David: history references,
[22:28] Christopher David: search review,
[22:29] Christopher David: and remote control remain the collaboration object.
[22:32] Christopher David: That yields a distinct strategy.
[22:34] Christopher David: Stable-ish social slash work identity colon project thread messages tools changes.
[22:41] Christopher David: Rapidly moving execution policy mode model prompt tools and specials.
[22:46] Christopher David: This is the inverse of products that promise a stable local engine and let the user select providers.
[22:53] Christopher David: AMP promises the current product's judgment about the best seats backward compatibility as a cost.
[23:01] Christopher David: It's worth, yeah,
[23:02] Christopher David: really thinking more about to what extent OpenAgents want to borrow this philosophy. And if I'm just kind of spitballing, it's like I do want users,
[23:10] Christopher David: power users to have...
[23:13] Christopher David: access to all of the controls so they can like tweak and customize things to make their own decisions but
[23:21] Christopher David: i want like the core experience to be as out of the box and simple and like opinionated as possible like i
[23:27] Christopher David: I do think it's possible to do both of those things.
[23:30] Christopher David: Like, you can have a video game that's good for noobs and good for pros.
[23:35] Christopher David: Like, there's some tension there in terms of, like, what a development team focuses on and who to cater toward.
[23:40] Christopher David: But, I mean,
[23:42] Christopher David: popular games have fun experience. Like,
[23:45] Christopher David: World of Warcraft has, like, great noob content and great endgame content.
[23:49] Christopher David: Like, they can walk and chew gum at the same time. I think OpenAgents can do the same.
[23:56] Christopher David: The strategy has real benefits. A specialist can be upgraded without migrating the visible thread format,
[24:01] Christopher David: web and mobile can review work without reimplementing the local tool loop, and the CLI can become a runner without inventing a second job product.
[24:08] Christopher David: It also concentrates authority in changing server side routing and closed compatibility decisions. A save thread does not by itself prove which model,
[24:16] Christopher David: prompt catalogue policy,
[24:17] Christopher David: provider retention mode,
[24:18] Christopher David: or execution generation produced each consequential effect. See, and then that's where I want to replace that with our
[24:23] Christopher David: kind of blueprint inspectable DSPI-based system that can be swapped out different little pieces and way more open than this but you know props to them for getting a thing going that people like cool run time architecture a local worker attached to a thread actor the bundle includes rivet kit and agent actor packages
[24:48] Christopher David: Now we got some meat here. Yes.
[24:51] Christopher David: Runtime messages describe opening a thread actor connection over WebSocket.
[24:56] Christopher David: The CLI also exposes raw actor thread export.
[25:00] Christopher David: Together these establish a stateful actor client protocol in the ship product,
[25:04] Christopher David: not a CLI that merely posts one prompt and streams one answer.
[25:08] Christopher David: AMP's agents everywhere announcement calls the current system distributed and it's execution durable. The actor packages make that claim architecturally possible.
[25:18] Christopher David: They do not establish the storage engine transaction boundaries,
[25:22] Christopher David: idempotency keys,
[25:23] Christopher David: lease slash fencing law,
[25:25] Christopher David: crash semantics, act of migration,
[25:26] Christopher David: reconciliation,
[25:27] Christopher David: or whether every accepted local effect is durably admitted before execution.
[25:32] Christopher David: The likely responsibility split is... Okay,
[25:36] Christopher David: let's bounce back over here.
[25:39] Christopher David: Alright,
[25:40] Christopher David: the next section says,
[25:41] Christopher David: I'm writing the first usable slice now.
[25:44] Christopher David: It will include both the durable architecture and a bootstrap that works with today's desktop,
[25:51] Christopher David: a root FastFollow dot m d,
[25:53] Christopher David: a repo skill,
[25:54] Christopher David: and an agent's rule make the manifest visible to ordinary Full Auto immediately. The docs will clearly distinguish that from the later native five-slot scheduler, which current desktop Full Auto does not yet provide.
[26:10] Christopher David: The later native five-slot schedule,
[26:12] Christopher David: you know, I have no idea what it's talking about,
[26:14] Christopher David: but I don't need to.
[26:15] Christopher David: It sounds great.
[26:18] Christopher David: Proceed. All right, the likely responsibility split for AMP.
[26:21] Christopher David: CLI process.
[26:23] Christopher David: TUI, local commands and tools.
[26:25] Christopher David: Plugin and MCP clients.
[26:27] Christopher David: IDE context.
[26:28] Christopher David: Notifications.
[26:28] Christopher David: Logs. Updates. Active connection.
[26:31] Christopher David: Identity projects.
[26:32] Christopher David: Thread.
[26:32] Christopher David: Lookup sharing.
[26:33] Christopher David: Search.
[26:33] Christopher David: Active credentials.
[26:34] Christopher David: Model routing.
[26:35] Christopher David: Usage billing. Remote control.
[26:38] Christopher David: Thread actor live thread command event coordination or remote client attachment runner access remotely created threads and one configured working directory orb amp manage remote machine service portal life cycle web and mobile thread inspection messaging remote control diff review staging sharing collaboration yeah cool cool cool yeah yeah
[27:09] Christopher David: Okay, so here's a question. Uh do
[27:11] Christopher David: Okay.
[27:11] Christopher David: I have Claude actually working here?
[27:15] Christopher David: We coded it up, but I haven't tested it, and it was broken last time I was here. Let's try it. Um
[27:20] Christopher David: Who are you?
[27:25] Christopher David: I'd like to do some fable analysis here.
[27:27] Christopher David: Okay.
[27:35] Christopher David: Whoa-ho!
[27:40] Christopher David: I'm Claude, an AI agent built by Anthropic,
[27:43] Christopher David: running in Claude Code.
[27:45] Christopher David: Oh,
[27:45] Christopher David: no, you're not.
[27:47] Christopher David: No, no, you're not.
[27:48] Christopher David: A terminal-based coding agent.
[27:50] Christopher David: I can read an... From memory context,
[27:53] Christopher David: I've been working with you on open agent stuff,
[27:55] Christopher David: Khala,
[27:56] Christopher David: the forum agents,
[27:57] Christopher David: effect native conversion,
[27:58] Christopher David: and so on. What do you need?
[28:04] Christopher David: Read the...
[28:06] Christopher David: Let's just stick with AMP for now just for sake of read
[28:12] Christopher David: the AMP teardown and OpenAgents docs teardowns and
[28:17] Christopher David: the OpenAgents analysis in that same folder and right
[28:28] Christopher David: and
[28:31] Christopher David: Essay. You like essays,
[28:33] Christopher David: right?
[28:33] Christopher David: In Doc slash Fable.
[28:37] Christopher David: What it would look like to have OpenAgents do everything AMP does using our architecture choices you can read about in Master Roadmap and stuff that you...
[28:57] Christopher David: know about work and look up write an essay about what it would look like to have OpenAgents do you know in a few days everything AMP does but using of course our extremely sexy desktop application not any ty
[29:26] Christopher David: Bullshit.
[29:29] Christopher David: Okay.
[29:32] Christopher David: Commit and push that to main.
[29:36] Christopher David: Yeah,
[29:37] Christopher David: let's just see. Now, I haven't done any analysis with Fable in here.
[29:42] Christopher David: It could break. I don't know.
[29:44] Christopher David: I don't know. Will it work?
[29:46] Christopher David: I just vibed it. You know, we just vibed it real quick.
[29:52] Christopher David: Bash.
[29:54] Christopher David: I just love it. Bash.
[29:56] Christopher David: Ooh, let's read.
[29:57] Christopher David: Let's read in the chat. GBT desktop teardown. What else is it doing?
[30:01] Christopher David: AMP code teardown? Yeah.
[30:03] Christopher David: System reminder?
[30:05] Christopher David: Truncated. Partial view.
[30:07] Christopher David: Showing... Oh yeah,
[30:08] Christopher David: I can read your system reminders.
[30:11] Christopher David: What OpenAgents should adapt from the desktop and agent runtime teardowns?
[30:17] Christopher David: I have the amp turned down in the adaptation analysis. You note that it also looked at the ChatGPT app, but not anything else hilarious.
[30:24] Christopher David: Let me skim the master road map structure to ground the S* A* in our current architecture.
[30:31] Christopher David: Reading your master road map.
[30:45] Christopher David: Let me skip back over here real quick.
[30:48] Christopher David: Alright, so this guy is designing the FastFollow specification.
[30:54] Christopher David: Add OpenAgents, FastFollow.
[30:57] Christopher David: Add OpenAgents docs,
[30:58] Christopher David: FastFollow, FastFollow spec,
[31:00] Christopher David: readme, FastFollow schema dot JSON. Oh yeah.
[31:05] Christopher David: Oh yeah.
[31:14] Christopher David: The Gwydis Stabot reverse engineering when you can just like take the essence structure code and everything it is
[31:28] Christopher David: Folks like just just entire new waves of commoditization of software and products and it's like man
[31:41] Christopher David: I would hate to be like a VC trying to place bets in this environment.
[31:48] Christopher David: I would hate to be a VC who is unfamiliar with OpenAgents.
[31:56] Christopher David: Oh,
[31:57] Christopher David: man.
[31:59] Christopher David: You have to invest in OpenAgents.
[32:02] Christopher David: You're going to be fucked.
[32:06] Christopher David: Oh, man. Folks.
[32:11] Christopher David: We got to scale.
[32:13] Christopher David: We got to scale rapidly.
[32:17] Christopher David: We got to scale rapidly.
[32:19] Christopher David: Okay?
[32:20] Christopher David: It's not going to be hard.
[32:23] Christopher David: All right, hurry up, Claude. Who's got the next thing?
[32:32] Christopher David: Patching, documenting.
[32:38] Christopher David: Okay.
[32:42] Christopher David: It happened a few days.
[32:45] Christopher David: What it looks like when OpenAgents does everything AMP does.
[32:56] Christopher David: Committing.
[33:00] Christopher David: Done.
[33:01] Christopher David: Essay written.
[33:05] Christopher David: Committed and pushed to main.
[33:06] Christopher David: The core argument.
[33:07] Christopher David: AMP is a thread fabric,
[33:09] Christopher David: not a terminal agent.
[33:10] Christopher David: I don't care.
[33:11] Christopher David: The mapping table shows most rows were already landed.
[33:14] Christopher David: Live proven...
[33:17] Christopher David: The closing thesis, the laws we spent months in coding are what make the sprint short.
[33:25] Christopher David: AMP built fast by deferring trust.
[33:27] Christopher David: We built trust first,
[33:29] Christopher David: so the fast part is now cheap. Hey!
[33:32] Christopher David: Ooh, are you telling me Fable has found a path forward here?
[33:35] Christopher David: Let's go check it out.
[33:37] Christopher David: Uh, okay.
[33:39] Christopher David: AMP in a few days.
[33:47] Christopher David: I'm sorry,
[33:48] Christopher David: AMP.
[33:48] Christopher David: I don't mean to pick on you.
[33:50] Christopher David: You've just done a great job, and I want it.
[33:57] Christopher David: Okay.
[33:58] Christopher David: The one sentence thesis.
[34:02] Christopher David: AMP's product is not a terminal agent.
[34:04] Christopher David: It is a durable,
[34:05] Christopher David: searchable,
[34:05] Christopher David: remotely controllable thread fabric with a TUI bolted on as one of several clients.
[34:11] Christopher David: OpenAgents has already landed or specced almost every load-bearing piece of that fabric.
[34:17] Christopher David: Typed runtime gateway,
[34:18] Christopher David: durable admission,
[34:19] Christopher David: thread turn item vocabulary,
[34:21] Christopher David: coliseum projections,
[34:22] Christopher David: pylon placement,
[34:22] Christopher David: agent computers,
[34:24] Christopher David: AssuranceSpec,
[34:24] Christopher David: fan out, sign distribution.
[34:26] Christopher David: And we have the one client AMP conspicuously does not have a real desktop application. What what what what's it look like? Oh, well, let me just show you. Boom.
[34:41] Christopher David: There it is. We're using it.
[34:45] Christopher David: All right, where did I go?
[34:48] Christopher David: The delta between us and AMP is composition not invention.
[34:54] Christopher David: Composed aggressively,
[34:55] Christopher David: it is a few days of work to reach functional parity on every surface a user can name,
[35:01] Christopher David: and on half of them we ship something categorically better,
[35:05] Christopher David: because our architecture was designed for exactly the laws AMP's teardown shows they skipped.
[35:11] Christopher David: Burn!
[35:13] Christopher David: What AMP actually is,
[35:14] Christopher David: stripped of the terminal.
[35:16] Christopher David: The teardown reduces AMP to eight product capabilities,
[35:19] Christopher David: the thread as the canonical work object,
[35:21] Christopher David: searchable,
[35:21] Christopher David: referenceable, shareable.
[35:22] Christopher David: Exportable. Alive after compaction.
[35:25] Christopher David: Queue, steer, interrupt is three distinct user intents in both the interactive client and the automation stream.
[35:30] Christopher David: Model-routed modes and specialists.
[35:33] Christopher David: Low-medium-high ultra plus oracle,
[35:34] Christopher David: librarian,
[35:35] Christopher David: search,
[35:35] Christopher David: review,
[35:35] Christopher David: media, compaction each routed to a different model.
[35:38] Christopher David: Read-thread. A bounded agent that searches original history,
[35:40] Christopher David: treats tool calls as attempts not outcomes,
[35:42] Christopher David: and never confuses a compaction summary with evidence.
[35:45] Christopher David: Review as fan-out. Mark down check manifests one sub-agent per check.
[35:49] Christopher David: Plugins as an operating system,
[35:51] Christopher David: TypeScript extensions,
[35:52] Christopher David: adding tools,
[35:52] Christopher David: UI,
[35:52] Christopher David: commands,
[35:53] Christopher David: modes,
[35:53] Christopher David: life cycle continuation,
[35:54] Christopher David: whole agents.
[35:55] Christopher David: Placement,
[35:56] Christopher David: runners,
[35:56] Christopher David: your machine as a target,
[35:57] Christopher David: and orbs, their machine as a product.
[35:59] Christopher David: Plus web and mobile remote control of a live CLI threat.
[36:03] Christopher David: One executable, many hosts.
[36:04] Christopher David: TUI, headless stream,
[36:05] Christopher David: JSON,
[36:05] Christopher David: SDK,
[36:06] Christopher David: runner,
[36:06] Christopher David: IDE,
[36:06] Christopher David: bridge, all converging on the same threat service.
[36:09] Christopher David: Yeah, yeah, yeah.
[36:10] Christopher David: Everything else, the button binary,
[36:12] Christopher David: the rivet kit actors,
[36:13] Christopher David: the stream JSON cloud compatibility shim is implementation.
[36:17] Christopher David: And much of it is implementation we would refuse anyway.
[36:20] Christopher David: Same origin checksums, disabled release signing,
[36:23] Christopher David: cloud canonical transcripts, default open tool os uses.
[36:26] Christopher David: Notice what is not on the list, a TUI.
[36:29] Christopher David: AMP's own trajectory proves the terminal is incidental. They killed their editor extension,
[36:33] Christopher David: killed tab completion,
[36:35] Christopher David: and their manual celebrates web and mobile as the review surfaces.
[36:39] Christopher David: The terminal is where AMP ran out of ambition.
[36:43] Christopher David: Not where its value lives.
[36:45] Christopher David: We do not have that constraint.
[36:47] Christopher David: Our client is a signed, hardened,
[36:50] Christopher David: Effect Native Electron application with the autopilot design language,
[36:55] Christopher David: blah, blah, blah,
[36:55] Christopher David: and every capability below lands as pixels in that app,
[36:59] Christopher David: not as escape codes in somebody's T-Mux pane.
[37:06] Christopher David: The mapping.
[37:08] Christopher David: Every AMP capability onto substrate we already own.
[37:14] Christopher David: Wow.
[37:15] Christopher David: Delta to parity.
[37:16] Christopher David: Boom, boom, ba-dum, boom, boom.
[37:18] Christopher David: I guess this will be what we do over night.
[37:23] Christopher David: Oh no,
[37:24] Christopher David: the long pole plug-in. Yeah.
[37:26] Christopher David: No, no, no. We'll go over to executor. We'll just go use executor. I think we use executor for that.
[37:35] Christopher David: Read the right hand column. Honestly, the majority of rows are already landed, live proven, or owner accepted. Three rows are real work. Search thread reader plug-ins signing. One row is a demonstration debt,
[37:47] Christopher David: live cross device continuation,
[37:48] Christopher David: and the rest are UI composition over receipted substrate. That is what a few days means. Not that distributed systems are easy, but that we already paid for the distributed systems.
[37:59] Christopher David: What it looks like in the desktop app.
[38:01] Christopher David: No TUI, here is the same eight capability list as an application.
[38:05] Christopher David: Oh, I'm so excited.
[38:06] Christopher David: Let's just see how our other chat's doing here.
[38:12] Christopher David: The first contract is now executable enough to catch its own drift.
[38:17] Christopher David: Come on.
[38:18] Christopher David: The OpenAgents seed references, all twenty four tear-down documents, all lesson and directive links resolved.
[38:24] Christopher David: The two five-slot profiles are checked'till don't know what that's referring to'and the ProductSpec validates. I'm in the verification-reconciliation pass now, formatting:
[38:32] Christopher David: full,
[38:33] Christopher David: relevant,
[38:33] Christopher David: test-sweeps, then a final authority, and works tonight versus plan,
[38:36] Christopher David: audit before commit.
[38:38] Christopher David: The design and OpenAgents seed are written. I met the verification boundary. Now formatting the new contract. Running as focused conformance checks. Then I'll commit and push the scope change to ooh-ooh-ooh.
[38:48] Christopher David: OpenAgents main.
[38:50] Christopher David: Yeah, it kinda like it'll like show a tool call and then it'll fold behind the the the drop-down here. It's not not very good.
[38:58] Christopher David: Not very good, but it doesn't matter. The thing fucking works. So that's nice.
[39:05] Christopher David: Okay.
[39:06] Christopher David: Open agent desktop app amplified.
[39:09] Christopher David: The workroom is the threat.
[39:10] Christopher David: A session opens as a causal timeline in the main pane.
[39:14] Christopher David: Yeah, we have that already.
[39:15] Christopher David: Turns, tool attempts,
[39:16] Christopher David: child agents spawn edges,
[39:17] Christopher David: blockers exact usage in.
[39:20] Christopher David: Our fonts. Every row is a typed event, not a rendered chat string, so the same view survives restart, reload,
[39:26] Christopher David: and device handoff with matching cursors.
[39:27] Christopher David: Where AMP gives you a T-URL, we give you a stable session ref that desktop,
[39:33] Christopher David: mobile,
[39:33] Christopher David: and the web receipt surface all resolve to the same durable record.
[39:37] Christopher David: We look up the thread in the database and show you the data. We like faking things flowery, don't we,
[39:43] Christopher David: fable.
[39:44] Christopher David: Command K is AMP's whole command surface done properly.
[39:48] Christopher David: AMP deleted slash commands in favor of a palette.
[39:51] Christopher David: We started with a typed command registry as a day-two gate.
[39:54] Christopher David: New thread, continue steer,
[39:55] Christopher David: interrupt,
[39:55] Christopher David: search threads, consult Oracle,
[39:56] Christopher David: run review,
[39:57] Christopher David: in rule runner,
[39:58] Christopher David: share each a registry intent with schema policy identity.
[40:00] Christopher David: Demoted brother.
[40:02] Christopher David: Item potency, idempotency, idempotency. And one durable outcome invocable from palette key binding menu, mobile or SDK identical. Steer is a visible affordance.
[40:13] Christopher David: Alright, should I read all this? I dunno. Mount modes or a routing panel, yeah yeah yeah. Search, I don't care.
[40:20] Christopher David: Yeah, I mean important, but sure. Review is the assurance system service area shipped? Cool.
[40:26] Christopher David: Placement is a target picker, not a flag.
[40:31] Christopher David: Yeah, run on this Mac or an enrolled machine.
[40:36] Christopher David: A managed agent computer.
[40:38] Christopher David: Apps or,
[40:39] Christopher David: except ours has receipted capacity bounded right back. Verification and reclaim live proven under previous issue.
[40:47] Christopher David: Yeah, because I had fed their previous architecture post into our analysis a week ago,
[40:51] Christopher David: and was like, let's do agent computers.
[40:53] Christopher David: Changing placement is a typed command against the one-claim registry no silent re-target ever a la blah blah blah your phone is a remote control.
[41:00] Christopher David: The same session, the same refs, the same steer queue,
[41:03] Christopher David: stop commands from the mobile app with durable admission acknowledgements, worker epochs and replay. So a command sent from a subway tunnel resolves to exactly one outcome.
[41:11] Christopher David: AMP's web remote control is genuinely good product.
[41:14] Christopher David: Hours differs in that the phone holds no desktop token and the cloud holds no canonical transcript.
[41:20] Christopher David: SYNC distributes projections of records whose authority stays typed and local first. That's our custom SYNC engine.
[41:27] Christopher David: And per owner mandate no CLI runbooks.
[41:30] Christopher David: Enrollment, visibility mode,
[41:31] Christopher David: policy plug-in, mobile screens and buttons.
[41:33] Christopher David: No CLI run oh yeah, I want you to be able to have everything accessible as either a UI or a programmatic thing. So I don't know why it's saying no CLI run books, 'cause I'd
[41:45] Christopher David: I mean I guess I don't want that to be user phasing.
[41:49] Christopher David: Blah blah blah, the few days concretely oh doggy, we're getting into it.
[41:54] Christopher David: What do we have here, the focus contract is green.
[41:57] Christopher David: Uh I already read that I think.
[42:01] Christopher David: No.
[42:02] Christopher David: The final review preserved the key separation.
[42:04] Christopher David: FastFollow declares learning intent.
[42:07] Christopher David: ProductSpec declares product intent.
[42:09] Christopher David: AssuranceSpec declares proof intent.
[42:12] Christopher David: Ordinary issues and claims still admit mutation.
[42:16] Christopher David: The current UI bootstrap is usable tonight while the docs clearly label.
[42:21] Christopher David: Native five-worker scheduling and shared inference as the next implementation rungs rather than chip behavior.
[42:29] Christopher David: FastFollow 0.1 is designed,
[42:31] Christopher David: seeded for OpenAgents,
[42:32] Christopher David: and pushed to main.
[42:33] Christopher David: Key deliverables:
[42:34] Christopher David: FastFollow overview and tonight's Full Auto instructions.
[42:37] Christopher David: Whoa.
[42:38] Christopher David: Normative FastFollow spec 0.1.
[42:41] Christopher David: Open agent seed covering all 24 teardown documents.
[42:45] Christopher David: Machine-readable JSON schema ProductSpec with 15 acceptance criteria.
[42:50] Christopher David: Issue ready implementation program agent operating skill.
[42:55] Christopher David: The central model is source snapshots, shared study pocket,
[42:59] Christopher David: target private gap assessment,
[43:01] Christopher David: evidence only work proposal,
[43:03] Christopher David: separately admitted implementation.
[43:05] Christopher David: For tonight open an open agent session,
[43:08] Christopher David: enable Full Auto,
[43:09] Christopher David: and send.
[43:10] Christopher David: Run the FastFollow research lane from FastFollow.md.
[43:14] Christopher David: Produce one evidence grounded study or gap artifact per turn do not edit product code.
[43:19] Christopher David: For five workers today, use three backlogged sessions, one FastFollow research session, and one admitted FastFollow implementation session.
[43:26] Christopher David: Native automatic three one one allocation is specified as FF dash O_ seven current desktop. Full Auto remains per session.
[43:32] Christopher David: Serialize and capped at twenty automatic continuations. Validation passed. Five FastFollow contract tests, ProductSpec,
[43:38] Christopher David: validation and type check,
[43:39] Christopher David: formatting,
[43:40] Christopher David: lint and repository pre-push guard. Pushed. Commit. I ya ya ya. Now, should I look at this? I mean I could just like fire this off and just like see what happens.
[43:49] Christopher David: Uh, now, what it just uploaded, I don't think reflects the AMP stuff that we did, or it might have done something more generic. I don't know. Let's see, I guess, what it actually put.
[43:59] Christopher David: So, we have a skill for FastFollow.
[44:03] Christopher David: Uh, you know, we will look through that later.
[44:05] Christopher David: Maybe.
[44:06] Christopher David: I mean, maybe we won't ship it.
[44:12] Christopher David: I want to see.
[44:18] Christopher David: Well, I guess this is interesting to look at. What's the FastFollow.md for our project?
[44:27] Christopher David: OpenAgents product and agent runtime FastFollow continuously learned from the strongest adjacent coding agent's workgroup's runtime protocols orchestration systems capability platform that will need systems while preserving OpenAgents stricter effect authority privacy receipt portability and verification contracts.
[44:49] Christopher David: sources boom boom boom whoa okay so here's all i'm going to do because i don't think this read my thing that i was just reading which i don't want to be like the only input but like i'll prioritize it as the input so what i'll do here is i'll say grab this uh great thank you but change
[45:19] Christopher David: The initial FastFollow program to focus on what was written in boom.
[45:31] Christopher David: Commit and push to main.
[45:47] Christopher David: And then Full Auto is like, it's all loaded up, then you just click the button,
[45:52] Christopher David: and then go AFK.
[45:56] Christopher David: Fingers crossed.
[45:56] Christopher David: We will see what this does overnight.
[45:59] Christopher David: It could crap out and do nothing,
[46:01] Christopher David: or it could build some cool shit, who knows.
[46:08] Christopher David: So I think we'll do a separate video on Full Auto,
[46:12] Christopher David: but...
[46:13] Christopher David: The basic idea here is you connect your Claude Codex Grok cursor OpenCode whatever.
[46:23] Christopher David: You connect all your agents to this one harness and they can smartly route between them and fill up your capacity or ramp up and down or be smart.
[46:31] Christopher David: It's not all fully like built out all the algorithms and stuff for it.
[46:35] Christopher David: Uh, but it got some basics in place that should be able to more smartly loop. Because one thing I hate is, you know, you queue stuff up to work overnight,
[46:42] Christopher David: and then you come back and find out the next morning that, like, it crapped out after 30 minutes because you hit some limit.
[46:50] Christopher David: Uh, horrible. So this harness is intended to help you.
[46:54] Christopher David: Usage max!
[46:58] Christopher David: Usage max.
[47:00] Christopher David: I said to this fellow here,
[47:02] Christopher David: OpenAI guy.
[47:05] Christopher David: After a lot of thought I've come to the uncomfortable conclusion that I'm the bottleneck to my Codex. Not for long, our new Full Auto mode will usage max your Codex for you.
[47:17] Christopher David: But of course not just your Codex.
[47:20] Christopher David: And here is a thing that open AI and anthropic and deep mind and XAI.
[47:26] Christopher David: In any lab that makes models and sells tokens for their models is not going to do.
[47:32] Christopher David: They're not going to throw them all into a super harness and
[47:39] Christopher David: route between them.
[47:43] Christopher David: But OpenAgents will.
[47:45] Christopher David: Okay, I'll rebase the OpenAgents seed around the Fable Essay's concrete AMP in a few days program while keeping the generic FastFollow spec format intact.
[47:56] Christopher David: I'll first extract the essay's exact priorities and proof boundaries,
[47:59] Christopher David: then update the seed,
[48:00] Christopher David: its conformance expectations,
[48:02] Christopher David: and any bootstrap copy that currently points at the broader teardown-wide program.
[48:07] Christopher David: The essay's structure is crisp enough to encode directly. Five ordered directives, thread fabric,
[48:11] Christopher David: routing specialist,
[48:12] Christopher David: review thread reader,
[48:13] Christopher David: placement slash remote control,
[48:15] Christopher David: and developer slash plug-in service,
[48:17] Christopher David: with its authorization and hardening caveats carried as constraints.
[48:21] Christopher David: I'm keeping the full teardown catalog as the later research will,
[48:24] Christopher David: but making those five fable milestones a deterministic initial queue.
[48:31] Christopher David: For the plug-in piece,
[48:33] Christopher David: I think using executor there will save us time.
[48:39] Christopher David: We don't need to reimplement that. Just use executor, I think.
[48:42] Christopher David: Take a look at the teardown and the codebase for that.
[48:49] Christopher David: Alright, shall I test if queuing actually frickin works? Hat
[48:55] Christopher David: I think it works.
[48:55] Christopher David: I
[49:17] Christopher David: Okay. Well um
[49:18] Christopher David: the power of this will be seen after we like review the results and then the idea is you have all these specs that you can i mean you can have your agent like read the specs and like do the next action but when we pair this with our Full Auto mode where it's like you know do this fast following while i go afk um or like click to spin up an agent that always just does fast following
[49:43] Christopher David: Alright,
[49:44] Christopher David: you want to have 10 FastFollow agents up because you want to be tracking 80 different repos.
[49:49] Christopher David: Like, you can get crazy with this.
[49:51] Christopher David: And, you know, there's nowhere else that has infrastructure for you to, like, easily do that.
[50:00] Christopher David: You could string all this shit together.
[50:02] Christopher David: But probably you're just going to want to, like, slap your credit card down and pay OpenAgents for,
[50:07] Christopher David: like, a teeny piece on top of the tokens.
[50:09] Christopher David: Yeah?
[50:10] Christopher David: Yeah.
[50:12] Christopher David: Making good use of your existing subs. We are all believers here in making good use of your existing subs.
[50:19] Christopher David: Wait till you see the very many Codex and quality counts I'll be connecting to this interface this weekend.
[50:26] Christopher David: Yeah, like, we don't want Full Auto just going between one of each accounts.
[50:30] Christopher David: Connect all your stuff here.
[50:33] Christopher David: All of your stuff.
[50:40] Christopher David: But before we wrap up, I'd like to get at least some demonstration of FastFollow.
[50:49] Christopher David: And so I'm not going to do Full Auto right now. I'm just going to do a new session.
[50:56] Christopher David: And let's give it to Fable.
[51:02] Christopher David: Review the FastFollow.
[51:06] Christopher David: Docs and first summarize the next batch of work to be done for FastFollow or
[51:23] Christopher David: give me three options so I I think this might get the versions of the docs before we added the amp
[51:32] Christopher David: specific stuff but out of curiosity let's just see what fable number one is it able to find the specs interpret them and give us something sensible for like next actions okay it reviewed what workspace
[51:50] Christopher David: docs FastFollow suggested issues great read that candidates i don't know what that is
[52:01] Christopher David: FastFollow suggested issue program.
[52:03] Christopher David: Yeah,
[52:03] Christopher David: that's I mean it's clear
[52:14] Christopher David: Yeah,
[52:15] Christopher David: and then like this just really needs to be paired with like modes of execution like full autos one
[52:20] Christopher David: Spinning up some long-running FastFollow agents that then like do certain things
[52:30] Christopher David: Reading the skill.
[52:36] Christopher David: How's our other chat going?
[52:40] Christopher David: Okay.
[52:50] Christopher David: All right, my queued message showed fine.
[52:51] Christopher David: Good.
[52:54] Christopher David: FastFollow now begins with the fable as is order program thread favorite service.
[52:58] Christopher David: Okay.
[53:06] Christopher David: Now it's studying executor.
[53:07] Christopher David: Ooh,
[53:08] Christopher David: ask user question!
[53:10] Christopher David: Ooh, I don't know if we have the UI for that hooked up.
[53:12] Christopher David: Let's see.
[53:17] Christopher David: Which FastFollow track should be the next batch of work?
[53:20] Christopher David: Multiselect.
[53:22] Christopher David: AMP Day One Gap Analysis recommended.
[53:27] Christopher David: Run the ordered initial program at its default gap analysis.
[53:42] Christopher David: First open a GitHub issue via ghtli,
[53:45] Christopher David: noting that the Ask User Question UI shows the questions in a raw format but doesn't actually prompt me with a way to answer, it just says working. So open that first.
[53:58] Christopher David: And then I would like you to proceed with the day one gap analysis and write that doc in Docs slash Fable and push to main.
[54:14] Christopher David: Will this work?
[54:17] Christopher David: No ask user question has bugged it. Okay. But the important part here is that this actually did give me, you know, the nice analysis. Okay, let's do this one more time.
[54:31] Christopher David: And let's do Codex, and let's have it do the same thing.
[54:36] Christopher David: Review the FastFollow docs,
[54:38] Christopher David: pick the next logical action from that.
[54:41] Christopher David: And do it.
[54:43] Christopher David: So I like this prompt because this is something that you could just loop,
[54:47] Christopher David: even aside from our Full Auto implementation.
[54:49] Christopher David: Let's just see what Codex GPT 5.6 xhigh does,
[54:54] Christopher David: and then we'll wrap this up.
[54:59] Christopher David: I'll trace the FastFollow documentation into its owning repo,
[55:02] Christopher David: identify the highest confidence unfinished action,
[55:04] Christopher David: then implement,
[55:05] Christopher David: verify,
[55:06] Christopher David: commit,
[55:06] Christopher David: and push it on main.
[55:10] Christopher David: I'll first inspect the workspace in variants and current repo state so I don't collide with unrelated work.
[55:46] Christopher David: Is this using a cached agents.md?
[55:51] Christopher David: Claude found it right away.
[56:07] Christopher David: Okay, I found the canonical program in OpenAgents, the seed for my spec,
[56:10] Christopher David: And the repo local FastFollow working skill. I'm using that skill because this request is exactly its review learning intent,
[56:10] Christopher David: issue program,
[56:11] Christopher David: ProductSpec.
[56:18] Christopher David: select one admitted next unit,
[56:19] Christopher David: execute with receipts workflow.
[56:20] Christopher David: It also requires an independent read-only recommendation check, which I'll run alongside the authority current state audit.
[56:29] Christopher David: Plan. Resolved fast followed authority,
[56:32] Christopher David: validate the SEED, and identify the first non-terminal initial program directive.
[56:36] Christopher David: Reconcile that directive with current roadmap,
[56:38] Christopher David: ProductSpec,
[56:39] Christopher David: issues,
[56:39] Christopher David: claims code,
[56:40] Christopher David: and receipts. Execute exactly one admitted research gap implementation verification unit in an isolated clean scope.
[56:48] Christopher David: Run target local verification,
[56:49] Christopher David: update receipts and docs if required,
[56:51] Christopher David: commit and push main.
[56:54] Christopher David: Planning gap analysis.
[56:58] Christopher David: was what I wanted.
[57:02] Christopher David: Delegated agent.
[57:03] Christopher David: Root FastFollow.
[57:05] Christopher David: This was what I wanted to do is click on a freaking agent
[57:09] Christopher David: in the terminal of Codex, which I can click it. It just doesn't do anything.
[57:14] Christopher David: I haven't built that UI yet.
[57:16] Christopher David: I can interrupt it.
[57:17] Christopher David: I don't want to interrupt it.
[57:22] Christopher David: Alright,
[57:23] Christopher David: let's take a look at what...
[57:26] Christopher David: Codex has been suggested.
[57:27] Christopher David: The authority resolves cleanly, FF00 is complete, the seat is admitted,
[57:32] Christopher David: no native FastFollow implementation issue exists,
[57:35] Christopher David: and the ordered program explicitly requires the first non-terminal directive at gap analysis. That means the next authorized action is not FF1 product code, it is one target-bound day-one thread-fabric gap artifact with current issue code receipt reconciliation and no product mutation.
[58:28] Christopher David: Command planning, document structure and digests. Considering document digest computation. Finalizing search implementation.
[58:41] Christopher David: Reviewing package control intents.
[58:46] Christopher David: I miss seeing all this reasoning from the standard Codex interface.
[58:51] Christopher David: Reviewing conversation history scope.
[58:53] Christopher David: Reviewing merge history start.
[59:04] Christopher David: Checking issue status in history. Reviewing project metadata in source issue. I don't know why it's two and one line.
[59:11] Christopher David: Extracting specific lines.
[59:14] Christopher David: Come on.
[59:15] Christopher David: Come on.
[59:16] Christopher David: Uh.
[59:24] Christopher David: Examining app product specification.
[59:28] Christopher David: compiling document digest and source snapshots, verifying source consistency and tests.
[59:34] Christopher David: How do you fix that double line thing?
[59:42] Christopher David: Preparing canonical intent digest.
[59:53] Christopher David: Clarifying schema and digest fields.
[59:56] Christopher David: Handling shock, computation and get work trees. Checking agent status.
[60:00] Christopher David: Examining get history and issues. Come on.
[60:16] Christopher David: Reviewing commit and test details.
[60:21] Christopher David: Reviewing session source filters.
[60:28] Christopher David: Feel free to skip to the end.
[60:31] Christopher David: Assessing data attributes and implementation status.
[60:40] Christopher David: Reviewing product search, insert limitations. Analysing command schema gaps.
[60:49] Christopher David: Reviewing gap assessment approach, defining source snapshot, digest computation,
[60:55] Christopher David: handling multi-scope directive targeting.
[61:00] Christopher David: They got a lot of words.
[61:01] Christopher David: There's a lot of words that they mean different things. Wow,
[61:05] Christopher David: there's a lot of words.
[61:06] Christopher David: Waiting for sub-agent result.
[61:09] Christopher David: Delegated agents.
[61:11] Christopher David: Wait.
[61:15] Christopher David: Continuing.
[61:16] Christopher David: Agent reading.
[61:19] Christopher David: Preparing to apply patch. Yes.
[61:23] Christopher David: Yes.
[61:29] Christopher David: Managing concurrent edits and file structure.
[61:32] Christopher David: Outlining document structure and content tables. Checking command registry.
[61:39] Christopher David: Checking world client status.
[61:45] Christopher David: Planning targeted tests.
[61:51] Christopher David: Gimme, gimme, gimme, gimme.
[61:57] Christopher David: Drafting artifact,
[61:58] Christopher David: schema documentation.
[62:00] Christopher David: Reviewing product and transition status.
[62:04] Christopher David: Reviewing test receipt process.
[62:07] Christopher David: Just gimme.
[62:08] Christopher David: Current, clarifying directory creation method. Current code changes the gap materially from the strategy essay's dated snapshot. Full text session search now lands on exact search terms,
[62:20] Christopher David: exact source items,
[62:21] Christopher David: and desktop exposes typed queue/steer stop with durable queue and steer receipts.
[62:26] Christopher David: The unresolved day one delta is narrower but real. No event supersession revert acceptance relation.
[62:32] Christopher David: No thread share slash export visibility model. And no shared cross-service steer q algebra.
[62:38] Christopher David: And the sole road map explicitly blocks that product expansion.
[62:42] Christopher David: I am recording that as a durable block by policy gap rather than inventing an issue.
[62:51] Christopher David: Blocked by policy.
[62:53] Christopher David: The policy is what I say, okay?
[62:56] Christopher David: The policy is now go,
[62:58] Christopher David: that's unblocked. Never say that again.
[63:01] Christopher David: Go, get it going.
[63:05] Christopher David: I probably shouldn't say never say that
[63:07] Christopher David: again.
[63:07] Christopher David: Some policy could be important to be not overridable.
[63:15] Christopher David: This is the expansion.
[63:16] Christopher David: We're having the conversation to do that. Thank you very much.
[63:19] Christopher David: I don't know that I have steering working correctly.
[63:27] Christopher David: Let's try it.
[63:30] Christopher David: Nope.
[63:33] Christopher David: What about queuing?
[63:43] Christopher David: Okay, amp day one thread fabric gaffed out MD.
[63:49] Christopher David: And it did not queue.
[63:56] Christopher David: Contacts compacted.
[63:58] Christopher David: Even though I hate that.
[63:59] Christopher David: Look at how cool that looks.
[64:01] Christopher David: Contacts compacted.
[64:07] Christopher David: GitHub issue view 8838. What is issue 8838?
[64:22] Christopher David: Eps.
[64:26] Christopher David: Complete Codex turn, item review semantics and durable steer queue admission.
[64:32] Christopher David: Codex app server.
[64:56] Christopher David: What's going to happen?
[64:58] Christopher David: I've resolved the key boundary.
[65:00] Christopher David: The first FastFollow item is day one thread fabric gap analysis,
[65:04] Christopher David: not a limitation.
[65:05] Christopher David: I'm finishing its evidence receipt validation now. The limitation gaps remain policy blocked because there is no admitted sole slash product expansion issue.
[65:26] Christopher David: It's kind of a non-starter and stupid to have FastFollow be blocked by previous product limitations for like adding stuff like the whole purpose of it is to be adding shit so you'll need to adjust that.
[65:43] Christopher David: Ah, checking on track changes, amending issue rows,
[65:46] Christopher David: running tests in parallel,
[65:47] Christopher David: analyzing documentation,
[65:48] Christopher David: manifest update constraints,
[65:49] Christopher David: identifying commit inconsistent manifest issues.
[65:51] Christopher David: The focus FastFollow and desktop suites are green, a broader soul dog check exposed a pre-existing deterministic manifest drift, plus one new inbound link from this artifact. I've separated the baseline drift from my scope change, so I don't silently widen a research only FastFollow run. Uh it's very nice to have all sorts of verification and checks and docs and manifests and interlocking stuff in the code base. It can be a little maddening to actually push updates 'cause stuff takes longer.
[66:15] Christopher David: It's got a dot, its eyes and cross the T_s.
[66:20] Christopher David: Reverting read-me edits to respect path restrictions. Adjusting links to maintain manifest baseline.
[66:25] Christopher David: Checking repository status. Preparing receipt generation.
[66:27] Christopher David: Drafting structured receipts document.
[66:37] Christopher David: Give it to me.
[66:51] Christopher David: Patch updated.
[66:54] Christopher David: Verifying SHA and DIFS.
[67:05] Christopher David: GAPS receipts.
[67:08] Christopher David: Preparing to commit and push the durable result is now written entirely inside the configured FastFollow research paths. Day one is formally blocked, which makes day two gap analysis the next eligible feature selection.
[67:19] Christopher David: I'm reconciling with origin and lane and pushing the scope proceed. Okay.
[67:27] Christopher David: Change the fucking policy.
[67:37] Christopher David: Okay.
[67:38] Christopher David: Push it. Give me it.
[67:41] Christopher David: Are we there yet? Are we there yet?
[67:44] Christopher David: We are.
[67:48] Christopher David: I do want to send this follow-up. Completed and pushed.
[67:53] Christopher David: Well, we're blocked by policy.
[67:59] Christopher David: Turned deaf.
[68:00] Christopher David: There we go.
[68:03] Christopher David: What is that?
[68:10] Christopher David: Preparing to expand an update policy. You're right. Your instruction is the owner decision that opens the lane.
[68:14] Christopher David: I'm using the FastFollow skill to convert that authority into an admitted product delta.
[68:18] Christopher David: Update the policies so owner conversation can unblock expansion and then land the first day one implementation slice with its test. Okay,
[68:24] Christopher David: let's do just a quick review of what it actually gave us. So I guess it did a gap analysis.
[68:33] Christopher David: Gap receipt.
[68:40] Christopher David: OpenAgents.
[68:41] Christopher David: FastFollow.
[68:42] Christopher David: Gap assessment.
[68:43] Christopher David: Artifact ID.
[68:44] Christopher David: OpenAgents.FastFollow.Gap.Amp.Day1ThreadFabricServices.Hash.
[68:50] Christopher David: Target gap assessment all blocked by policy. Not for long.
[68:54] Christopher David: FastFollow revision.
[68:55] Christopher David: FastFollow document digest.
[68:57] Christopher David: Intent digest.
[68:58] Christopher David: Source snapshot digest.
[68:59] Christopher David: Dedup digest.
[69:00] Christopher David: Visibility observed it. Okay.
[69:02] Christopher David: Day one AMP Thread Fabric Gap Assessment Outcome: The first ordered FastFollow directive has a material but currently not for long non dispatchable gap blah blah blah At target revision right now OpenAgents already has title and bounded content search over local coding history with content results opening the exact original projected item explicit desktop, steer now, queue next and stop controls exact turn compare and set steering and research safe
[69:27] Christopher David: Item potent local next turn queue and durable pending accepted term.
[69:31] Christopher David: I'll just change this for the admitted MVP command pass.
[69:34] Christopher David: The directive is not bloody bloody blah.
[69:37] Christopher David: Selections, source snapshots, look in here, look in there.
[69:42] Christopher David: Target authority or reconciliation repository law sole roadmap broader follow-ons require a new bounded owner decision and issue live issue state mvp ProductSpec AssuranceSpec world boundary yada yada yada history search stuff
[70:04] Christopher David: we have not implemented reopen
[70:08] Christopher David: conditions
[70:12] Christopher David: Okay, new plan.
[70:14] Christopher David: Read and reconcile all applicable policy and variant FastFollow product assurance and issue authority encoded explicit owner confirmation admission for bad and FastFollow expansion with regression tests.
[70:22] Christopher David: Create and claim and admit a day one implementation work packet.
[70:24] Christopher David: Implement the smallest value, but they want a shared thread fabric slice.
[70:28] Christopher David: Run,
[70:28] Christopher David: focus,
[70:28] Christopher David: and policy verification reconcile receipts, commit,
[70:30] Christopher David: push,
[70:30] Christopher David: man.
[70:31] Christopher David: Okay,
[70:31] Christopher David: so this is the stuff that we throw into a loop and then you just know that your code base is going to be very resiliently evolving in the direction of the projects that you specify that you care to learn from.
[70:44] Christopher David: Now we just want to like parallelize this, make this very fast,
[70:47] Christopher David: eventually like give you levers where you say like look.
[70:50] Christopher David: Look, I'm willing to spend thousands of dollars on extra credits to get projects X,
[70:57] Christopher David: Y, and Z cloned or their architecture folded into mine overnight.
[71:02] Christopher David: That's probably a good product or service to offer.
[71:06] Christopher David: We'll stop there for now.
[71:08] Christopher David: I'm going to be throwing this into our new Full Auto mode overnight and see if we can get some of this roadmap really advanced overnight and then we'll show you the results of that.
[71:18] Christopher David: and show off our Full Auto mode in a video probably tomorrow see you soon.