Atomic and core terminology

0:00 It doesn't have to be as complicated and just happy to hand this off to Adam so you can just go and start cooking, man. Yeah, thanks for inviting me, Ray. Hi everyone. My name is Alex and I came to the live stream last time to talk about verifiable coding agent runtime called Atomic. And what I wanted to cover in this discussion is how you can start to use Atomic and apply it to real world engineering tasks.

0:20 And I also wanted to cover how it might be a paradigm shift with how you use coding agents. And specifically introducing a way of determining when a task is complete and how to think about multi-hour autonomous task, multi-day autonomous task, and eventually tasks that are running for weeks autonomously. And I thought one of the the best way to introduce Atomic is to just give a brief overview of the terminology and what all this stuff means. And then we'll actually do a deep dive and open the coding agent, the coding agent runtime in the terminal and go through real world examples of the primitives of Atomic and a cool, a cool demo with a $10,000 SaaS app application from Swix.

0:40 And so stay tuned for that. So the first term is the runtime. And I talked about this in the last video or the last live stream. And that's where the environment is where the agents execute. So it owns the sessions, the tools, the model, and the state. And then there's this idea of verifiable and verifiable runtime. And the verifiable component is where you have a claim that's backed by evidence from a coding agent and it can inspect and rather than expecting the model to use its capabilities to determine whether a task is done, it uses deterministic gates or other LLM as a judge verifiers.

0:40 And then the verifiable runtime combines these ideas of runtime and verifiable. And then there's these general terms that have been talked about, but without much clarity in my opinion, which is the idea of a loop, which is a you can think of it similar to a for or a while loop and you implement check fix and repeat tasks. And there's this idea of bounding, tracking iterations. And then there's a graph, which just expands this idea into nodes where each node can be viewed as an agent session and those can have handoffs as edges.

0:40 And this whole structure can be a DAG, a directed acyclic graph. And it's a live inspectable record. And then graph engineering combines these ideas into a way that engineers can think about formulating their own graphs where they can take a process and define a graph that represents that process. And that's where graph engineering and workflow creation are closely related. And Atomic gives you these verifiable primitives that allow you to define graphs. And this engine is the the thing that we're going to be talking practically throughout this stream.

1:00 This is exciting, man. I'm like, I'm so glad to have you here and like we have some other folks here, here in the actual office, here in San Francisco. And so this is going to be really, really cool. I'm really excited to get it in here. Because this is a live stream, just want to let you know, I will have an edited version. There will be timestamps available down below. So I just want to give a shout out right now to some of the early folks who are currently showing up, ISS ZOMG, we're live.

1:00 Also sent Adroid as well as live. Just feel free to drop your comments below. We're going to get to some question and answers in a little bit, but I just wanted to make sure for the folks who are showing up right now, we wanted to get you started as fast as possible. And so this is brought to you by the great folks like you who are showing up. So if you're finding a lot of value, if you found a lot of value in the last stream before, make sure you share this out and get your friend to join in.

5:00 uh because we have a lot to cover here and it's going to be really exciting for all of you. I'm just really delighted to get this started. So, yeah, without further ado, man, I'm gonna let you cook. Yeah. Awesome. Uh, the the next thing I wanted to show is, look, let's get, let's get up set up with everything. So, in the, in the last video, I described how to use Herder and Atomic, but I I just wanted to reiterate that so you guys can follow along.

5:30 So, the get started page, uh, for for the get started page, I recommend going to docs.bestdani.ai and there's a quick start here that describes how to install Atomic. So it's an NPM install. And the other thing I recommend installing is a tool that Ray may have mentioned in his videos. I think he mentioned it in the last live stream, which is Herder. And this is a T-mux alternative, and what this allows you to do is have a multiplexer so that you can detach from a remote machine and have the work continue.

5:30 And this is really convenient because, uh, you, you might have seen all those memes where people are trying to keep their laptop lid open and like, actually creating products where they try to keep that pride open. So, uh, I recommend installing this tool and it actually fits well with what Atomic does in terms of running multi-hour sessions. With that setup, I'm, I'm gonna switch over to my installed version of Atomic, so we can actually go through a crash course that I prepared.

6:10 It's pretty dense, but it should cover the very basics and how you use Atomic and then go into more power user mode and actually building a real project with that or debugging debugging certain things in your project and how I approach that and how I create specs. So let me switch over to the terminal now. Cool. So what, well, he gets that set up is getting the terminal stuff set up. Uh, huge shout out to Dion, who's also watching on the stream as well.

6:40 We got Phil Blanchet in the building. We got Jala and FLA, and, uh, let's go ahead and see if we can get back into the stream here as we got this whole thing going up. So this is Herder, we have live. And, uh, this is a really cool UI. Yeah, Herder has this nice idea of spaces, so you can create new tabs and inside of the tabs, you'll see that each tab is denotes a specific repo that you're on.

7:10 I only have one repo open here, but in this case, it shows you the main branch and then you can create new sessions by clicking on on this. It's like a, it's like a new window and T-mux. And then there's a menu bar where you can detach from Herder as well. And it allows you to group, uh, panes together and also shows you the status of agents. So let me open Atomic and we'll get into this deep dive.

7:50 So there's a I recommend cloning this crash course repo that is pinned as one of the YouTube comments in the live stream, but I'm, I'm repasting it here so you have access. Uh, if you search for Atomic crash course under the same repo for Atomic, then you'll have access to this repo, so you can go at your own pace and explore the concepts. If you look in the read me.md file, there's an entire overview of what we're going to be going through and it has all the prompts so you can reproduce everything, uh, offline.

8:20 So let's start with the very basic usage of Atomic. And Atomic itself has the base primitive of a coding agent, so you can use things like at mentions for files. So if you use this at tag, you can reference files and then be able to, uh, pass that directly to the context of the coding agent. And then there's also the ability to execute batch commands as well, or PowerShell if you're on Windows. So I can, I can do something like this.

8:50 And it will, uh, run shell commands and the nice thing is you can actually then direct those shell commands to the agent if you do, uh, double exclamation point. So this will go into the context window of the model. And I can ask, what files do you see in this folder? In this case, it just reran the command, but it would be automatically loaded in the context window. And then, uh, you can also, uh, just use it like a regular coding agent and and and just interact with the system, but that's that's really the tip of the iceburg.

9:10 That's that's more boring stuff. And then, uh, the last, one of the things that I introduced in the last stream was this idea of hash line editing. So Atomic has an optimized version of the edit tool for coding agents, which allows it to uh replace text much more more effectively. And the way that this works is, uh, if I do read greater. If I type read greater.ts and then change only the greeting punctuation, it uses this hash line edited tool, which uses content hashes for editing instead of the traditional replace tool that's used in coding agents.

10:00 Uh, this is more context efficient because in traditional edit tools, the model has to regenerate everything that it wants to replace. So, it's very error prone. And this is something that I adopted from OmyPi. And the other feature that I really liked about Atomic is it has it has this cool interactive ask question tool. So, if I send a message like scaffold a config file, don't write anything, first ask me a question, there's this interactive interface, and there's also pop-ups that can show on the right hand side.

10:20 If you want to get a, if you ask the model to create a visual diagram of what are the pros and cons of a particular engineering approach, it can create those, and as you tab around, uh, it'll show you visually what is the difference between certain approaches. So, in this case, I'm just going to enter my responses, and this ask user question tool is a is a great way to gain clarity when working with a coding agent and make sure that you will have aligned your intent with what the task is going to do.

10:20 And I'll and I'll show you, uh, this will be incredibly important as we try to scale these systems and and the philosophy of Atomic because I see a future where we have to align the way we approach a problem, uh, and spend a lot of time doing that, because if the agents are going to go about solving a problem for multiple hours or multiple days or weeks, you don't want to lose that, uh, lose that that much time from, uh, a mis misintent.

10:20 Yeah. Because it it can be really expensive to have to go back from, uh, a run that was multiple days long. That's right. That's wild. Cool. This is so cool. And we have file plan, a file-based plan to do. This is also another typical feature in harnesses, but this actually allows Atomic to maintain context, uh, across compaction cycles better. And you can, you can do something like actually, let me close that. You can say something like plan test coverage for this feature and create one to do per exported function and list all to-dos.

11:00 So, what this does as I was mentioning, is it maintains a file-based memory of what the current task is being worked on. And that allows the model to have an idea of what's important across compaction cycles. This is really important for multi-hour, multi-day tasks where the model needs to maintain continuity. Oh. And you can also observe what it wrote, but these are like internal notes that the model has and, uh, but the the other thing I wanted to show is, uh, you have this this idea of file-based to-dos.

11:00 And, uh, to-dos are a way that you can optimize what's in the session context. So, Atomic has this idea of sessions, uh, which are similar to coding agent sessions, but sessions can also be in workflows which we'll get to later in the in this guide. But to understand a a session, uh, I, I would, the way I would think about it is there are these fundamental operators, like treeing, forking, and cloning sessions. So, the idea of treeing is you can switch back towards branches of context, and this is an idea that was introduced by Pi, where you can actually go back in user and assistant messages and be able to select a particular message in the history.

11:00 So, it's like you're reverting at a message level, which is really convenient if the model took a path that was derailed, and you're trying to correct its its uh, trace. And, uh, this is like a low-level memory management technique that you can do. So, I see. Like from an operating system context, you can do something. To keep the context clear and so forth. Yeah. Yeah. So, just can we like recap a little bit of kind of what's been happening so far for the folks who are just joining in, because there's obviously some folks who are just joining in right now, trying to figure out, okay, I just got started with Atomic and so the first things that you kind of need to get started are, you know, download Hurter, H E R D R, that's going to be basically able to run your coding agent.

11:00 Uh, preferably if you have like a dedicated machine, this is probably the best way to do this, because if you're running it on your own Mac, as soon as you close it down, uh, your agents will pause or stop, and then tell you to turn it back on. So, what Hurter will allow you to do if you're connecting via SSH, was it will allow you to keep that session alive. So, when you SSH into that computer again, you type in Hurter, boom, all of your sessions will load back up, and it'll just kind of feel like.

5:37 So it wastes more context. And there's this idea of if you have a, a passing test case, then you don't need to include that in the context window, because that information is irrelevant to the model and just misguides it. Uh, so it's actually incredibly important how well you compact. And that's why Atomic is the only, uh, coding agent runtime to my knowledge that has this verbatim compaction implementation at, like a production scale for multiple hours and multiple days.

5:40 Uh, and then cursor comes in with the bug review. Uh, and then augment app comes in with the bug review as well. And then I have other agents that are reviewing these reviews and then it does a repair fix, right? So like I had zero touching atomic, then launches off cursor, saying, hey, um, go ahead and start this repair round with all these things that have been called out and figure out what's going on. Uh, and then here's here's the commit that's going in.

6:10 So, um, it's nice because you can see like while I've been here on this stream, I have not even been taking a look at what's been going on. And you can see even like an hour ago, uh, it's just been doing all these repairs. So item eight, the three lines brought into the one documentation. And then here's the three major repairs that still need to happen. And the fixes and all the different stuff that are coming in.

6:40 So it's just kind of looping and fixing itself. And this is normally what I have to, like spend a lot of time, you know, reviewing by hand and then kind of trying to wrangle all the agents and they're all just kind of doing their own thing. So, uh, and this is kind of where we're at right here. So I can just say, while this is running, let's say, what is the latest status on what is going on right now?

7:00 And so we can see this is, this main agent right now is currently running on Opus 5 high. Uh, and that's my orchestrator in essence. This is my atomic session. I'm just going to get out of here because I think you just have what you need. You'll figure it out. And it's like, well, like it was in my skill file. It was supposed to follow it. How come it's not so procedural? Based. So this is the next evolution is basically runtimes.

5:54 And that's what atomic is providing is just, how do you have a system that can kind of sort of guide itself uh, in the environment that it's in, and then.