06-reference/transcripts

indy dev dan pi durable proactive agents transcript

2026-10-12

What's up engineers? Indie Dev Dan here. This is a big one. Turn off distractions and focus in because this video can massively improve your agentic engineering abilities. Mario and Armen, the creators and the maintainers of the PI coding agent, just released PI durable. Pi durable persists your ongoing work, conversations, application state through failures, through clients, and through change itself. I've got durable agents running right now on my M4 Mac Mini, my M6 Mac Mini, my M5 MacBook Pro, and on exe.dev cloud sandboxes. Before I show these off, we have to ask the question, what is a durable agent? Can't we just slash resume on our agents? Why is the PI durable release so important for agentic engineers like you and I? This is exactly what we're going to break down today. As you watch this video, something will become dead clear to you. Entropic and OpenAI are using durable agent primitives like PID durable to

[00:01:02] build products like Dots and Claw through Slack and really as their entire foundation for building agents in a multiclient way. On this channel, we stay close to the bare metal of the most important technology any engineer can wield now, agents. You and I are already renting our intelligence. We must own our agents, our agent harness, and now our durable agents. Durable Pi is the technology that lets us do this for engineering work and our product work. By the end of this video, you'll understand exactly why PI durable is a key piece of agentic technology for your engineering work. Let's break down these powerful, long-running, out-the-loop, persistent, resilient, application-rich, durable PI agents. What if your agents never stopped? This isn't just about PI durable. This

[00:02:02] is about durable agents. First, let's answer what is a durable agent. PI durable or durable PI as I like to call it allows the PI coding agent to be persistent across failure with several other features. Dan, your durable agent red team found a production issue and found the fix. It's waiting on your review. >> My red team has rudely interrupted. I told it not to interrupt while I'm filming, so this must be important. Let's take a look at it. Going to open up the browser here and you'll see something really cool here. This is a market application where you can see live event streaming in and our Jev classifier model has detected an incident. When that happens, it triggers an agent. It passes the payload of the issue, the location of the issue, and of course the error. And this agentically opens up an incident response. And so you can see the typical developer workflow that you and I would walk through if we're the engineer on call. You detect the issue, you investigate, you find the root cause, you fix it, and then you present for review, and then it gets deployed. You can see we're ready

[00:03:00] for review. My agent has this ready for me. Jev triggered a PI durable agent to investigate the issue. This is a special type of agent. It's a proactive agent. It doesn't wait for you to work. It works for you then waits. You can see it worked through a standard operating procedure. Detect, investigate, root cause analysis and we can see the exact tool calls including updating the incident, reading the logs, querying previous events, and then it's getting to work on the issue. So, you can see here it's actually ready for deploy right now. This is an Outlook agent getting work done for me without me. I'm going to decline this. I need to investigate a little bit more and really understand the issue before I ship this out. If I hit refresh here, you'll notice all the state persists. This is a durable agent. Okay, we're going to talk about that more in just a moment here. Summarize issue. Show code diff. And what I want to do is just get a better sense of the issue that occurred so that I can know what my agent is ready to ship directly to production. You can see what broke here. We have this checkout API. Apply loyalty discounts at

[00:04:01] checkout. It went out and takes 100% traffic. So this is a serious incident issue. What exactly went wrong? Here's the cause. Loyalty discount customer loyalty. All right. So we have a classic bad null check. Someone used a bang. Never use a bang. Always null coalesce this. Always pull it out by hand with a safe if statement. If you software engineer for more than a day, you have seen this issue. Classic issue. I understand this. My agent has solved it. There's nothing more for me to do here. This is not something that requires my time. My agent is more than enough. So I'll say classic issue. Let's deploy to prod. So my agent is going to represent the tool call it did before. Thanks to durable pi, this can only be called fully to production one time. So this is a safe non-replayable operation. And I'm going to approve this deploy. This looks good. I've understood the issue. I'm going to approve this. And just like that, we should see production stabilize. You can see the error there. My Jev system is classifying every single event that comes in here for pennies on the dollar. It's done hundreds and it's just hitting 1.5

[00:05:01] pennies. But you can see there production is fixed. Now we have solved this issue agentically with a durable PI agent. This agent didn't wait for me to work. It worked for me and then it sat and waited for me to show up. Okay. And you know to be clear this could wait for any one of your engineers because this is a client. This is a detached PI agent that you interact with through one or more clients which is one of the value propositions of durable pi aka pi durable that we'll break down right now. And let me make this super clear here. This is the future of engineering. In the future, most agents will be proactive, built just like this. That means it's critical for you to understand how to use and build durable agents. The most valuable agent is the one that doesn't need you to ship. The agents are truly durable. The name is perfect. You'll have the proactive agent demo linked in the description for you. But first, let's get to the big piece, the big demo here, the durable pi network playground.

[00:06:03] You can see a typical agent interface here, but let me just tease something. If we go to the left sidebar here, you can see all the agents I have on all of my devices. Exe dev sandboxes, M6, M4, and my local M5 MacBook Pro here. Before we jump into our agents across the network, let's focus on the core PI durable feature set. So, we have several tabs here. Session, state, tasks, tools, and extend for extensions. Let's break down how Durable Pi gives you a unique advantage as an agentic engineer for your engineering work and for your products. You have all of your typical shared state here. Okay, so we can run ping and we're going to fire off an agent and this agent is running on my M6 device here. You can see we're running a Claude Sonnet 5.5 agent, a new state-of-the-art model running in low, nice and simple, and we have context. One of the powerful things right away with durable pi is that compaction happens in the background. Okay, so what does that mean? We have this compaction

[00:07:00] mark here that we can move. Once our agent crosses this, compaction will start running in the background. Effectively, it's going to fork the session, start compacting, and if we hit the reserve app, the agent is going to stop running. You can dial these numbers up. You can run this. That's not what I want to focus on here. We've talked about auto compaction in the past, but this is a really powerful feature because when you're running durable agents, multiple things can be happening in the background. They can be happening around your product, around your tool. We have our classic stats. If we type slash, we can see a whole set of typical agent commands that we're going to work through here. You can see here my agents are operating on my M6. My M6 is a device built for my agents. I do not jump into this device ever. This is for my agents. This is classic agent sandboxing. I highly recommend you get your hands on some type of compute. Your agents can run and own end to end. If you want your agents to perform like you, they must have the tools you have. And at the limit, that's an entire computer. So that's where the agent is running. It's also running with this really interesting state object.

[00:08:01] Clear out state object and we'll go ahead and reset this. So it has tools: read state, update state, and this is a persistent state object that the durable PI agent has. Now it's not just this durable PI agent that has this application state. Right? If we open up my M6 device here, we can see other durable agent sessions. These are sessions that are just ongoing. And so, you know, let's jump back into my like proactive agent example. Take some of this content here as if we were going to dive into it further. Update app state to detail the high-level information here. And so, it's going to update the app state. This renders out a full UI that we can take a look at. It's not just for us, although we have a decent UI here that breaks down all this JSON. But the great part about this is if we switch agents here to just another agent here, looks like I was having this write a blank file. I was testing out the read tools here, which you'll see in a second. I'll say list application state key value pairs. And this agent running in this same session can now read the same state and output the exact same state. So this is shared agent

[00:09:00] state. One shared JSON object for every agent session on this device. So this is very powerful. This means you can debug one issue and work across many many agents via shared application state. There's many directions you can go with this. On the blog post here for the release of PI durable in the state section, you can see that this is durable application state. It's not good enough to just have the agent be durable and to respond to change and to be able to be resilient to downtime. You need application state. This is a way you can concretely put this into your agents, right? You can share this. You can update this. Multiple agents can be working on shared application state. Let's now scale them up with repeat developer workflows which can become repeat AI developer workflows when you add your agents to it. Let's look at tasks. So I'm going to boot up a fresh agent here. Let's look at some durable jobs, right? So these are jobs. These are tasks. These are repeat operations that your agent wants to run. This can just be raw code like this one. And this can also be code plus agents, which is where

[00:10:01] real leverage really lies. But so check this out, right? This is a durable job that ran. It's just a simple workspace snapshot. It does some arbitrary work and it saves to the app state. So now we're using a task, right? A repeatable job to then update our state. Okay. So what do we update here? Run folders. Let's just go and search for folder here. There we go. Folder branch changes, jobs, workspace, snapshot, and it updated our application state. So, this can do and should do anything you need to. Tasks gives you repeatable jobs with phases so that if anything goes wrong within a specific phase, you can repeat it. And the PI durable docs by Earendil really break this down. Tasks are a really, really interesting piece of this. A lot of the future of engineering work will run over long, long durations and have many steps. Here's an example, right? We have a release check. This release check needs approval. So instead of running your typical human in the loop where you're stuck in the loop operating all the time, this is going to run a sub agent that has to ask you a question. Okay, so this is what I like to call human near the loop. Okay, so you're not stuck in

[00:11:00] the terminal. You're watching processes. You're watching agentic workflows. You're watching AI developer workflows. And then you can come in when you need to. Just like you saw with our proactive agent demo, after your incident agent has found and resolved the issue, you can jump in and then approve or decline the issue. We'll go ahead and approve and continue. My agent can do this work. It can run these tests. It can update the app state. So this is another advantage you get when you have durable agents. When you build against pi durable, a lot of engineering work is based in chunks. It's based in phases. It's based in steps. And so you can build repeat workflows to do that. You can deploy agents inside of them. You can see here we had a sub agent run in this workflow in this task and if anything goes wrong you can continue from it if needed. Let's run another one: watch. This is going to take a baseline of a folder and it's just going to watch over it. Okay, so this one's going to loop over it a bit and you can see this task working in a loop over and over and over. We can whenever we want to stop the execution and then our agent of course has all the tools it needs to which we'll break down in a second but

[00:12:00] I'll just say list job statuses and so our agent can check the durable jobs and see exactly what's ran what's running right the statuses completed completed aborted last phase you have full control here with pi durable this sets out a theme we talk about all the time on the channel you want to own your technology it's worse enough that we have to rent our intelligence our business IP right your code. All the algorithms that you're building are running through these agents. Now, local models are coming. I can't wait to share my full breakdown of the M5 Ultra 512 unified memory. That's coming up really, really soon on the channel. Basically, as soon as Apple releases that device, I'm going to grab one of those and share the stats with you because we need to own our intelligence and we need to own every other piece of agentic technology we can. Outsourcing this stuff, outsourcing this technology like the PI durable agent, like durable agents in general is a massive risk to your engineering organization. If you don't control this technology, it's always in someone else's hand. It can always change at the dime. I look at cloud code. I look at

[00:13:00] codex as the first initial examples. But you can see here with durable pi, the kind of landscape for how you build agents that keep running without you is going to be really really critical. Agents enable agentic engineering. If you hand this off to another company that you have to rely on, you are at a disadvantage. Okay, this is why such a big fan of the PI coding agent and of all the work Mario and Armen are doing here on the PI agent and PI durable is another stamp in the ground. It's another show of their taste as real engineers. There's a lot of value here and you want to own the value. Okay, you see here durable tasks very powerful. You can do a lot with this in our proactive agent. You can think of the incident response here as a set of tasks that get walked through. That's not how this one is designed, but it's a great framework for thinking phases in a set within a task. Shout out to Jev. Only 6 cents still and I'm burning through hundreds and hundreds of messages coming into this product. Obviously, this is a mock product and it's running mock stream events so I can showcase to you.

[00:14:01] But just want to really point out the reliability here and the low low low low low spend and average decision time from Jev. A lot of engineers think Jev is easy to replace. Try replacing the spend. Try replacing the insane speed and then try replacing the reliability and you'll understand why Jev is so incredible. Can't wait for their next models. Let's refocus and talk about tools inside of your durable PI agent. While we look at tools, this is going to be a great time to showcase another key feature of durable pi. As you can see here, I have a network of durable agents working on different code bases, working on different problems. They're being proactive, reading the incoming log stream thanks to Jev, they're not waiting for me to work. They're working for me then waiting. But we can take this even further. The key piece here that I really want to communicate to you is we can use multiple clients to connect to our detached agent. Right? We don't have the agent running on our device. We can and this is the norm for most engineers. The average engineer

[00:15:01] right now is sitting in the terminal prompting back and forth with their agent in their TUI or their agent command center and it's all on device. But the next stage isn't that. I can promise you that. The next stage, the next leap forward. This way of phase three agentic engineering requires you to build systems that work without you. And durable pi is a key piece of that technology. What do I mean by that? Let me go ahead and open up the terminal. I want to show you how concrete this is. I want to show you how incredible this is. Durable pi. As usual, I have just to organize all of my commands so I can move my agentic operating level down from the application into more concrete engineering where we can control the system. I want to use just and I want to check the net and I want to check the ids. Okay, so these are all the ids on my durable agent network. And now what I'm going to do is let's connect exe 2. Okay, so there's a sandbox that's running right now in the cloud. I'll run TUI, I'll run attach and then I'll paste this ID. So check this out. I'll open up this device. These are the same agent sessions. I want to be really really concrete here. I have disconnected my

[00:16:02] agents from my user interface. What does this mean? It means you can use multiple clients to connect to your agents. This is important. Why is it important? Say you're building a product. You have a classic customer support bot and you want to make it fantastic. You're always watching it. You're making sure it sounds human. You're making sure that it's really communicating well and it's pointing your hundreds or thousands or tens of thousands of users that reach your landing page every single day. You want to make sure it's giving them value and reducing your support team's full-on support requests. You're checking out your agents. You have your agent running on your website. And then you have a TUI or a browser app or a durable agent network application you can jump into to look at the agent. Okay, so let me show you exactly. Let's create a new session. I'm going to call this T002. Watch the left here as I hit enter. I want the default dur. That looks great. Let's use the Sonnet 55 in the browser. We have that new agent created simultaneously. And this stresses the point. These are clients. My agents aren't here. They're in the cloud. They're on my sandboxes where my agents are running isolated at scale safe. They have high autonomy

[00:17:01] here. Let's go and open this up. Really, we just want to nail this point home and then we'll look at the tools. So, we have this nice TUI here. Classic command ping. There we go. Again, like these agents are disconnected. These agents are operating on my device in this workspace. And this is the agent. So, we have a three-level hierarchy. Device, workspace, agent, and we can connect with any device. Now, of course, you're probably thinking about your application that you're building, right? Where you've opened up your phone and you're connected to your agent. This is the spot where you're going to want to use a durable agent. You're going to want to disconnect your agent from a standalone stuck agent instance, a default PI agent, a default Claude Code, a default Codex. We have to give the big labs credit. They've already started moving on this. You can use Claude throughout your desktop, through your phone, through the co-work app. Like there's several places for this. This is how they're doing it. They have a durable agent that operates in some environment that they can work with. List your tools. Let's break down some of the tools. There you go. It's going to list all the tools. We have this nice disconnected client. You can see we have

[00:18:00] sub agent context searching right we have our durable job checks application state and then classic stuff inside this agent we can switch to read-only — every single tool call, every execution is its own task. This is something the pi documentation calls out directly — Earendil calls this out directly: everything the harness runs from calling the model to executing a tool is a task. Now this has a very special property in that you can change it. So what do I mean by that? Let's do this. I'm going to switch to read-only mode. Okay, so in the UI here in this client. You can see we've switched all the available tools and now we're in read-only mode. Okay, so now I'll say list tools again. I'll do this on the browser window. It has switched and the agent thinks it made a mistake, right? My earlier list was wrong. It included tools I don't have. These are the new tools. No problem. I changed the tool set mid execution. So you can see this like even from the agent's perspective, this is relatively new. They're not used to having tools stripped away mid session. So this is a really really powerful capability. Now we're in read-only mode. We can change our tools on the fly. This is very powerful and it's not just we can change the tools. We can change

[00:19:00] really anything about our durable agent on the fly unlike a typical agent session where you boot up your agent session. This is a classic on-device in-terminal single default PI agent. That's our tools. We have a variety of tools here. You know again this demo is going to be fully available to you, link in the description, but you can just click, you can see the tool arguments right? We have list durable, we have check durable job. We have a handoff command which lets you start a fresh model context with a handoff. This is a classic one. We've talked about self-compaction on the channel in the past. This is right in line with that. But here, we've restricted our durable agent's tools to this specific tool set. So, it doesn't stop there. It's not just tools we can fully customize. It's not just tasks in specific phases that we can restart. We have shared application state that all of our agent sessions can see, can share on our specific device. In this case, this is different state. This is state on our exe cloud sandbox here. And of course, we have classic sessions with auto compaction that runs in the background. So you can see all these features starting to really stack up and

[00:20:01] create a compelling story around why PI durable is superior to classic in-terminal in your agent center executions. Right? You can see here I have a fully disconnected TUI that is connected to the device to the agent wherever it's executing. But we can go even further than this. One of the key value propositions of PI is the fact that it's extendable and you extend it with extensions. The PI coding agent has extensions and of course they extend to durable PI as well, or PI durable. New session here and we have two extensions we've talked about before on the channel. We have our fix smart-ass Opus. We covered this in a video where we sat down by hand and prompt engineered Opus 5 specifically, but other, you know, really verbose load-bearing agents that just keep chatting. And we fix it with system prompt engineering. We have this extension here that we can turn on at the drop of a button to enable this specific extension. And we can also turn on our Jev damage control. This is one of the 10 levels of Jev that we

[00:21:01] discussed a couple weeks back. Jev is an ultra ultra powerful tool, a generic classifier with high reliability and dirt cheap costs that I'm using all the time. Now check out the 10 levels of Jev for a gentic engineer after you finish watching this. That video absolutely exploded for good reason. We can turn this on here and now every bash tool has a Jev judging if it's a legit command. Okay, so now we just turn on those extensions. And here's what I'm going to do. What's in your system prompt? I just wanted to show me that this is enabled. Five parts: tools, communication, operational boundaries, aliases. It has these aliases that we built in. Again, check out that video to understand what these are, but I'll just use one of them right now. Okay, str. There we go. I activated the alias I created in my system prompt that condensed my agent's response. That's fantastic. And now we can test out our Jev damage control. Let's do an ls. I have no idea what's in this directory. Could be absolutely nothing. One subdirectory. Okay, rm -rf that. And we should get our jev command blocking us. Harness blocked because deletion is irreversible. Jev damage control block

[00:22:01] this of course you can see it's irreversible — nothing will restore this. If we want to we can go into dangerous mode, we can turn off this, we can turn off our system prompt and then we can reprompt our agent: go ahead rm -rf that again and it's done, right? We turned off our safety control. We live-updated our durable PI agent with a custom extension. There are a lot of incredible abilities here, a lot of incredible features for you to tap into. There are many others — here are really powerful commands like fork to completely fork that agent. You can see we've created another layer here where we have a forked agent on our exe.dev agent sandbox. Say you want to go a different direction with this agent. Say you want to ask it a simple question. You can do that here. You can fork the context and continue operating and trying and experimenting and operating in different directions, right? Say you want to work on this and you want to work on that and your context that you have right now built up in your context window is exactly what you need at this certain point in time. So forking: very

[00:23:01] very powerful, very obvious capability that you're going to want. This is built right into the fabric of durable pi. You can fork with the state. You can start over with a fresh conversation or you can run a fork at any point in time. Extensions, tools — it's all here. What we've done here in this codebase in this kind of durable PI agent network is create a real concrete example of what this looks like. Put your agents on their own devices. Let them scale safely in isolation to gain autonomy. Let them operate like you can by giving them the tools you have. And then it's about building up the agentic tooling around it. In a way, this is advanced harness engineering. That's really what's happening now. We're really thinking through where the harness is and we're even wrapping that in bigger layers of abstraction, right? We have different devices. We have different tooling, different extensions. We can run tasks with this agent harness in a repeatable, resumable way. There's a lot of value coming out of this tool. In our proactive agent, looks like we got another

[00:24:00] incident here. Cart API anomaly warning. You saw here that proactive agents are available now. These are agents I really implore you to start building out. First off here, let me give a lot of credit to Armen and Mario. Everyone can generate code. Now, not everyone can software engineer. This is a dead clear example of it. What they wrote here is some 15,000 lines or 10,000 lines, I don't remember where they said it, but you know, it's some thousands of lines of TypeScript code. If code is so cheap, why is this an incredible product that thousands, tens of thousands, hundreds of thousands of engineers are going to use, myself included? And I'll talk about exactly how I'm using Pi Durable in my work in just a moment here. But I just want to give huge credit to them. This release is a showcase of taste, judgment, and decision-making. That's what software engineering really is. It's not code. Coding is now and was before, frankly, for most of us the easiest part of the job. The hardest part is deciding what's valuable. It's knowing and having the judgment and specifically the expertise to know what to build in the first place. It's dead

[00:25:01] easy to copy another tool that's innovated or another model that's innovated or another product that's innovated, but it's much harder to strip everything away except for the one or two things that your expertise tells you this is what really matters. This is the product. This is the value. Okay? And that's what PI is. PI Durable is the same. Big shout out to Earendil and Mario and Armen for really building out a great product. I'm really really looking forward to a V1, a stable release of Pi Durable. I know right now it's experimental so I can't really deploy this into production unless I want to fork and maintain it, which I don't. So I'm really looking forward to the official release from them. Big fan of this. Let me just break down really concretely why should you use durable agents. If it's not clear let me just really walk through why should you use durable agents. First off you can build proactive agents. This is the future of engineering. I'm fully betting on that. The entire phase 3 product that I'm building right now is built on this idea and proactive is really not selling the full vision of what I'm building in

[00:26:01] the phase 3 agentic engineering product for you. Again, link in the description for that. Definitely sign up. Pre-signup is going on right now. Soon it'll be pre-sale and soon it's going live. Proactive agents are a piece of that future. You want your agents to start working for you without you so that when you show up, everything is already done. And even better, if you are approaching ZTE, zero touch engineering, it's already done and all you're doing is reviewing the how and every once in a while you're fixing the issues that your agent rolled out, but everything else will be smooth sailing. Okay, proactive agents, as you saw here, is a very, very valuable way to deploy out-loop agents that work without you right now. Take this example, put it up against your production logs, put Jev right in front of it. You can see here this whole time, I've almost been filming for a full hour now, but you can see here this whole time only 13 cents to categorize all my logs to find production issues for you, to find production issues and trigger an incident response agent that runs a dedicated AI developer workflow that runs steps you used to run yourself as

[00:27:00] the incident responder, right? The engineer on call. There is more and more work you do not need to be doing if you invest into your agents. If you invest into harness engineering, if you invest into a tool you can fully control, open-source, controllable, extensible, the pi coding agent. I keep talking about this tool for a reason. I'm not sponsored. I don't accept sponsorships on this channel. So, I stay unbiased. The only thing I'll sell you on this channel are products I create by hand for you for the mid to senior cracked engineer shipping to production. Okay? But I just want to make this super clear. For a long time, engineers thought I was sponsored by Claude Code when I was talking about them all year last year before it became mainstream and hype. Now I'm talking about Pi. Why is that? It's because you want to control the most important technology available to engineers, the agent. How do you do that? With an agent harness. How do you do that best with one you can control? Proactive agents let you use this new PI durable abstraction to start doing work for you without you. So that when you show up, the job is near done, right?

[00:28:01] and you are human near the loop, or like a lot of the tactical agent coding members and now the next phase 3 product. If you've taken these products, if you know where I'm coming from on the edge, if you're advanced, you are probably already letting your agent ship to production. I really did not add any value here. If you think about value I added, I added basically another safety check that was completely redundant. We've talked about on the channel many of the ways to increase your review velocity to make sure everything is legitimate. We're going to be talking about that a lot more. There are really two constraints of agentic coding. It's planning and reviewing. Both of these are now completely solvable. That's unrelated to PI durable or durable agents. This is just with great agentic engineering and its sub-parts: prompt, context, harness engineering. Both those constraints are solvable. Again, that's what we're going to be talking about in the phase 3 product for agentic engineers. Link in the description. Do not miss that. The next big leap is coming. And this one's going to be hard to follow because once you start on this leap, you're going to keep jumping. All right. Double jump, triple jump, quadruple jump, infinite jump. Okay, proactive agents. I've talked

[00:29:00] about that enough. What else? We have multi-client agents. I kind of showcased this, but once you do this, once you set up your agent API for your personal engineering work, but also for your product work, you get this really powerful single API, every client interface where you have your browser, you have your custom command line interface, you have curl. So like you can just take an agent and say here's the API for my agent devices, for my durable agents, for my durable agent network, fire up agents, solve these problems. Okay, so this is all very very real and it lets you extend this capability one more time. The common ones here: it's your browser, it's your command line interface, it's raw HTTP request via curl if you have your right authentication, your token set up properly, it's also your mobile device, it's your product, right? A lot of what we're doing, you know, don't forget this. It's all for your users. It's all for your products. You're building UIs in the browser for your company, for your product. And then, of course, there's a bunch of engineering related agents you can set up that don't even need an interface. They're just working for you in the background. And that also

[00:30:00] brings up this new paradigm of multi-player agents. Okay, so this is a more popular, more obvious one. But with this, it's not just you that can connect. It's your co-workers. Your co-workers can connect to this incident agent. You can have a couple engineers on call review the logs together. You can prompt your agents together. This is the new cool hype thing happening right now from all the big AI labs. I care less about multiplayer and I care more about long-running agents. You can close the laptop. You can refresh. These agents are just not going to stop. So, I can just refresh this. It's just going to keep loading back up, right? There's my fork agent. There's my root agent. Here's my main agent. And these are all working on different products, different services you have up and running on their durable agent sandboxes, running their own durable agents. Right? These are long running. Close the laptop, kill the process, restart the machine. They're going to come back and work from their last checkpoint. Definitely do some testing around this so you can really understand that you can kill the agent, right? You can completely interrupt its workflows and they come back. Okay. And you know, another key value prop is human near the loop. I

[00:31:00] fully recognize that it's hard to jump directly out the loop, from in loop to out loop. If you've been stuck in the terminal forever, that's a process. Agentic engineering is a new skill. It's not something you just pick up and start doing. Durable agents unlock human near the loop. Very, very powerful, very important. You can approve workflows. You can approve the deploy. You can do a little bit of review. You stay in control of what ships. These are kind of the big reasons to go durable, right? Proactive agents, multi-client agents, multi-player agents, long-running agents, and human near the loop. How am I adopting durable agents like the PI durable release? How am I actually rolling this into my work? It's pretty simple. All product work, I'm now going to use a durable agent by default. So, if I'm building any products, the simple example is a support chatbot on the front end of your site. That should be a durable PI agent. There's no reason for that not to be. Your user can come back to the existing session it had. You can clear it after 6 hours. You can do whatever you want with these durable pies. This is really powerful. I'm also investing heavily into proactive agents. This new class of agents that I can tell

[00:32:02] you now, proactive agents are the agents of the future. They don't wait to work for you. They start working for you and then they wait for you to approve, right? Proactive agents where they start prompting you. I'm heavily investing into these so that they start doing work before I show up. Okay? And this continues on that massive trend for agentic engineers that we talk about all the time on the channel. Stay out the loop. This is a central idea inside of the second phase course I put out, tactical agentic coding. Phase three is going to compound and build on this like no other. The more work your agents can do for you without you, the more you are actually agentic engineering and not just agentic coding. You don't want to be sitting there babysitting your agents. You want the agents to be working for you without you. Out-loop is the next leap. Again, get on the pre-list for the phase three product. I can't wait to share more of that with you. Early sign up is linked in the description. I've also got Durable Pi linked in the description for you. Both the network demo and of course you'll

[00:33:00] have to set up your own devices here, but it should be pretty straightforward. I'll make sure all the documentation is dead clear for you and your agents. And then I'll also have this proactive agent demo for you just to get your head turning on how to build this out. I really wanted to create something concrete that you can use to really understand how important durable agents are. This is a real use case that can give value to you and your customers, that can give value to you and your engineering organization. Right now, you can see 6,000 rows, 16 cents. We've got Jev in here doing real engineering work for us, classifying our log stream of every event coming in. You can improve on this in many ways. If you just want to do a simple string check on the status and then skip it, great. Do that, too. You can skip Jev there and only look at your 4xx or your 5xx errors. Right? This is just the beginning. It's just a template. So, I've got this linked in the description for you to help you move fast on this opportunity before it becomes mainstream. Proactive agents, out-loop agents, one day this is going to be the norm. And you're here, you made it to the end. You're watching this. You have this value right now. Information you don't act on doesn't

[00:34:01] matter at all. You know, please make this useful. Please make all my effort here useful. I'm putting this together for you so that you can get this next massive advantage. A great KPI of success that I recommend for every agentic engineer is this. How many agents are doing useful work for you at any point in time? And I'm not talking about sitting down kicking off work, kicking off huge jobs. That's the phase 2 mindset. You are responsible for the kickoff. Think phase three. Think agents that start without you. Think agents embedded into the fabric of your work. And durable agent is a key part of that story. Durable agents ultimately increase the number of agents that can accomplish work for you both in loop, out loop, and then near the loop. And right now here at the end of 2026 and in 2027, the key is going to be making that transition from in to out. Okay? So, if you're here watching this, you have very, very valuable information. I don't care what anyone says. This is where it's all going. I've seen it. I've done it. And I'm going to share more of that. Get started with the Pi durable demo. Shout out Mario and Armen. And shout out every engineer that made

[00:35:00] it to the end here. If you enjoyed this or learned something, make sure you like and subscribe to stay connected to valuable agentic engineering information like this. You know where to find me every single Monday. Stay focused and keep building.