YT YouTube2Text

YouTube2Text → Transcripts → Pi Durable PROACTIVE Agents: Jev Triggers My ON-CALL Pi Agent

Pi Durable PROACTIVE Agents: Jev Triggers My ON-CALL Pi Agent — Transcript

by IndyDevDan · 7,382 words · 1,073 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00What's up, engineers? Indy Dev Dan here.
0:02This is a big one. Turn off distractions
0:04and focus in because this video can
0:06massively improve your agentic
0:08engineering abilities. Mario and Armin,
0:10the creators and the maintainers of the
0:12Pi coding agent, just released Pi
0:15durable. Pi durable persists your
0:18ongoing work, conversations, application
0:21state through failures, through clients,
0:23and through change itself. I've got
0:26durable agents running right now on my
0:28M4 Mac mini, my M6 Mac mini, my M5
0:33MacBook Pro, and on exe.dev cloud
0:36sandboxes. Before I show these off, we
0:38have to ask the question, what is a
0:40durable agent? Can't we just /resume on
0:43our agents? Why is the Pi durable
0:46release so important for agentic
0:48engineers like you and I? This is
0:51exactly what we're going to break down
0:52today. As you watch this video,
0:54something will become dead clear to you.
0:56Anthropic and OpenAI are using durable
0:59agent primitives like Pi durable to
1:01build products like dots and cloth
1:04through Slack, and really as their
1:06entire foundation for building agents in
1:08a multi-client [music]
1:09way. On this channel, we stay close to
1:11the bare metal of the most important
1:13technology [music]
1:14any engineer can wield now, agents. You
1:17and I are already renting our
1:18intelligence. [music] We must own our
1:20agents, our agent harness, and now our
1:23durable agents. Durable Pi is the
1:25technology that lets us do this for
1:28engineering [music] work and our product
1:30work. By the end of this video, you'll
1:31understand exactly why Pi durable
1:34[music] is a key piece of agentic
1:36technology for your engineering work.
1:39Let's break down these [music] powerful,
1:41long-running, out-the-loop, persistent,
1:44resilient, application-rich, [music]
1:45durable Pi agents.
1:52What if your agents never stopped?
1:59This isn't just about Pi durable. This
2:02is about durable agents. First, let's
2:03answer what is a durable agent? Pi
2:06durable, or durable pies as I like to
2:08call it, allows the Pi coding agent to
2:10be persistent across failure with
2:13several other features.
2:15>> Dan, your durable agent red team found a
2:17production issue and found the fix. It's
2:20waiting on your review.
2:21>> My red team has rudely interrupted. I
2:23told it not to interrupt while I'm
2:24filming, so this must be important.
2:26Let's take a look at it. I'm going to
2:27open up the browser here and you'll see
2:29something really cool here. This is a
2:30market application where you can see
2:32live events streaming in and our Jev
2:34classifier model has detected an
2:36incident. When that happens, it triggers
2:39an agent. It passes the payload of the
2:41issue, the location of the issue, and of
2:43course the error. And this agentically
2:45opens up an incident response. And so
2:47you can see the typical developer
2:49workflow that you and I would walk
2:51through if we're the engineer on call.
2:53You detect the issue, you investigate,
2:55you find the root cause, you fix it, and
2:56then you present for review, and then it
2:58gets deployed. You can see we're ready
3:00for review. My agent has this ready for
3:02me. Jev triggered a Pi durable agent to
3:05investigate the issue. This is a special
3:07type of agent. It's a proactive agent.
3:11It doesn't wait for you to work. It
3:13works for you, then waits. You can see
3:15it worked through a standard operating
3:17procedure, detect, investigate, root
3:19cause analysis, and we can see the exact
3:21tool calls including updating the
3:23incident, reading the logs, querying
3:26previous events, and then it's getting
3:27to work on the issue. So, you can see
3:29here it's actually ready for deploy
3:30right now. This is an outloop agent
3:32getting work done for me without me. I'm
3:34going to decline this. I need to
3:35investigate a little bit more and really
3:37understand the issue before I ship this
3:39out. If I hit refresh here, you'll
3:40notice all the state persists. This is a
3:43durable agent, okay? And we're going to
3:44talk about that more in just a moment
3:46here. Let's summarize issue, show code
3:48diff. And what I want to do is just get
3:50a better sense of the issue that
3:52occurred so that I can know what my
3:54agent is ready to ship directly to
3:56production. You see what broke here, we
3:58have this checkout API apply loyalty
4:00discounts at checkout. It went out and
4:02takes 100% traffic. So this is a serious
4:04incident issue. What exactly went wrong?
4:06Here's the cause. Loyalty discount
4:08customer loyalty. tier. All right, so we
4:10have a classic bad null check. Someone
4:12used a bang. Never use a bang. Always
4:15null coalesce this. Always pull it out
4:17by hand with a safe if statement.
4:20software engineer for more than a day,
4:21you have seen this issue. Classic issue.
4:23I understand this. My agent has solved
4:25it. There's nothing more for me to do
4:27here. This is not something that
4:28requires my time. My agent is more than
4:31enough. So I'll say classic issue. Let's
4:33deploy to prod. So my agent is going to
4:35represent the tool call it did before.
4:38Thanks to durable pie. This can only be
4:40called fully to production one time. So
4:43this is a safe non-replayable operation.
4:45And I'm going to approve this deploy.
4:47This looks good. I've understood the
4:48issue. I'm going to approve this. And
4:50just like that, we should see production
4:52stabilize. You can see the error there.
4:53My Jev system is classifying every
4:56single event that comes in here for
4:57pennies on the dollar. It's done a
4:59hundreds when it's just hitting 1.5
5:01pennies. But you can see there,
5:02production is fixed now. We have solved
5:04this issue agentically with a durable
5:07pie agent. This agent didn't wait for me
5:09to work. It worked for me and then it
5:11sat and waited for me to show up. Okay?
5:13And you know, to be clear, this could
5:15wait for any one of your engineers
5:16because this is a client. This is a
5:18detached pie agent that you interact
5:21with through one or more clients, which
5:23is one of the value propositions of
5:25durable pie, aka pie durable, that we'll
5:28break down right now. And let me make
5:29this super clear here. This is the
5:31future of engineering. In the future,
5:33most agents will be proactive, built
5:35just like this. That means it's critical
5:37for you to understand how to use and
5:39build durable agents. The most valuable
5:42agent is the one that doesn't need you
5:45to ship. The agents are truly durable.
5:47The name is perfect. You'll have the
5:49proactive agent demo linked in the
5:51description for you, but first, let's
5:53get to the big piece, the big demo here,
5:55the durable Pi network playground.
5:57[music]
6:03You can see a typical agent interface
6:05here, but let me just tease something.
6:06If we go to the left sidebar here, you
6:08can see all the agents I have on all of
6:10my devices. You can see our dev
6:12sandboxes, M6, M4, and my local M5
6:15MacBook Pro here. Before we jump into
6:17our agents across the network, let's
6:20focus on the core Pi durable feature
6:22set. So, we have several tabs here,
6:24session, state, tasks, tools, and extend
6:27for extensions. Let's break down how
6:29durable Pi gives you a unique advantage
6:32as an agentic engineer for your
6:33engineering work and for your products.
6:35You have all of your typical shared
6:37state here, okay? So, we can run ping,
6:39and we're going to fire off an agent,
6:41and this agent is running on my M6
6:44device here. You can see we're running a
6:45Claude Sonic 5.5 agent, a new
6:48state-of-the-art model, running in low
6:50thinking, nice and simple, and we have
6:52context. One of the powerful things
6:54right away with durable Pi is that
6:56compaction happens in the background,
6:57okay? So, what does that mean? We have
6:59this compaction mark here that we can
7:01move. Once our agent crosses this,
7:03compaction will start running in the
7:04background. Effectively, it's going to
7:05fork the session, start compacting, and
7:07if we hit the reserve at, the agent is
7:09going to stop running. You can dial
7:11these numbers up, you can run this.
7:12That's not what I want to focus on here.
7:13We've talked about auto-compaction in
7:15the past, but this is a really powerful
7:16feature because when you're running
7:17durable agents, multiple things can be
7:19happening in the background. They can be
7:21happening around your product, around
7:23your tool. We have our classic stats. If
7:26we type slash, we can see a whole set of
7:28typical agent commands that we're going
7:29to work through here. You can see here
7:31my agents are operating on my M6. My M6
7:34is a device built for my agents. I do
7:36not jump into this device ever. This is
7:38for my agents. This is classic agent
7:40sandboxing. I would recommend you get
7:42your hands on some type of computer
7:44agents can run and own end to end. If
7:46you want your agents to perform like
7:47you, they must have the tools you have.
7:50And at the limit, that's an entire
7:51computer. So, that's where the agent is
7:53running. It's also running with this
7:55really interesting state object.
8:01Clear out state object and we'll go
8:03ahead and reset this. So, it has tools,
8:05read state, update state. And this is a
8:07persistent state object that the durable
8:09Pi agent has. Now, it's not just this
8:12durable Pi agent that has this
8:13application state, right? If we open up
8:15my M6 device here, we can see other
8:17durable agent sessions. These are
8:19sessions that are just ongoing. And so,
8:21you know, let's jump back into my like
8:23proactive agent example, take some of
8:25this content here as if we were going to
8:27dive into it further, update app state
8:29to detail the high-level information
8:32here. And so, it's going to update the
8:33app state. This renders out a full UI
8:35that we can take a look at. It's not
8:37just for us, although we have a decent
8:38UI here that breaks down all this JSON.
8:41But, the great part about this is if we
8:43switch agents here to just another agent
8:45here, looks like I was having this write
8:46a blank file. I was testing out the read
8:48tools here, which you'll see in a
8:49second. I'll say uh list application
8:52state key-value pairs. And this agent
8:54running in this same session can now
8:56read the same state and output the exact
8:58same state. So, this is shared agent
9:00state. One shared JSON object for every
9:02agent session on this device. So, this
9:05is very powerful. This means you can
9:06debug one issue and work across many,
9:08many agents via shared application
9:10state. There's many directions you can
9:12go with this. On the blog post here for
9:14the release of Pi durable, in the state
9:16section, you can see that this is
9:18durable application state. It's not good
9:19enough to just have the agent be durable
9:21and to respond to change and to be able
9:23to be resilient to downtime. You need
9:25application state. This is a way you can
9:27concretely put this into your agents,
9:30right? You can share this, you can
9:31update this. Multiple agents can be
9:33working on shared application state.
9:35Let's now scale them up with repeat
9:38developer workflows, which can become
9:40repeat AI developer workflows when you
9:42add your agents to [music] it. Let's
9:43look at tasks.
9:48So, I'm going to boot up a fresh agent
9:50here. Let's look at some durable jobs,
9:51right? So, these are jobs. These are
9:52tasks. These are repeat operations that
9:55your agent wants to run. This can just
9:56be raw code like this one, and this can
9:58also be code plus agents, which is where
10:01real leverage really lies. But, so check
10:03this out, right? This is a durable job
10:04that ran just a simple workspace
10:06snapshot. It does some arbitrary work,
10:08and it saves to the app state. So, now
10:10we're using a task, right? A repeatable
10:12job to then update our state. Okay, so
10:14what did we update here? Run folders.
10:17Let's just go ahead and search for
10:18folder here. There we go. Folder branch
10:19changes, jobs, workspace snapshot, and
10:22it updated our application state. So,
10:23this can do and should do anything you
10:26need to. Tasks give you repeatable jobs
10:29with phases so that if anything goes
10:31wrong within a specific phase, you can
10:34repeat it. And the Pi Durable docs by
10:36Rondell really break this down. Tasks
10:38are a really really interesting piece of
10:40this. A lot of the future of engineering
10:41work will run over long long durations
10:43and have many steps. Here's an example,
10:45right? We have a release check. This
10:46release check needs approval. So,
10:48instead of running your typical human in
10:50the loop where you're stuck in the loop
10:52operating all the time, this is going to
10:53run a sub agent that has to ask you a
10:56question. Okay, so this is what I like
10:57to call human near the loop. Okay, so
10:59you're not stuck in the terminal. You're
11:01watching processes. You're watching
11:03agentic workflows. You're watching AI
11:04developer workflows. And then you can
11:06come in when you need to, just like you
11:08saw with our proactive agent demo. After
11:10your incident agent has found and
11:12resolved the issue, you can jump in and
11:14then approve or decline the issue. We'll
11:16go ahead and approve and continue. My
11:17agent can do this work. It can run these
11:19tests. It can update the app state. So,
11:21this is another advantage you get when
11:23you have durable agents. When you build
11:25against Pi Durable, a lot of engineering
11:28work is based in chunks. It's based in
11:30phases. It's based in steps. And so, you
11:32can build repeat workflows to do that.
11:34You can deploy agents inside of them.
11:35You can see here we had a sub-agent run
11:37in this workflow, in this task. And if
11:39anything goes wrong, you can continue
11:41from it if needed. Let's run another
11:43one, right? Change watch. This is going
11:45to take a baseline of a folder and just
11:46going to watch over it. Okay, so this
11:47one's going to loop over it a bit and
11:49you can see, you know, this task working
11:51on a loop over and over and over. We
11:52can, whenever we want to, stop the
11:54execution. And then, our agent, of
11:56course, has all the tools it needs to,
11:58which we'll break down in a second, but
12:00I'll just say uh list job statuses. And
12:02so, our agent can check the durable jobs
12:04and see exactly what's ran, what's
12:06running, right? The statuses. Completed,
12:08completed, aborted, last phase. You have
12:11full control here with PyDurable. This
12:13hits at a theme we talk about all the
12:14time on the channel. You want to own
12:16your technology. It's worse enough that
12:18we have to rent our intelligence, our
12:20business IP, right? Your code, all the
12:22algorithms that you're building are
12:24running through these agents now. Local
12:26models are coming. I can't wait to share
12:28my full breakdown of the M5 Ultra 512
12:33unified memory. That's coming up really,
12:34really soon on the channel. Basically,
12:36as soon as Apple releases that device,
12:38I'm going to grab one of those and share
12:40the stats with you because we need to
12:41own our intelligence and we need to own
12:43every other piece of agentic technology
12:45we can. Outsourcing this stuff,
12:47outsourcing this technology like the
12:49PyDurable agent, like durable agents in
12:51general, is a massive risk to your
12:53engineering organization. If you don't
12:54control this technology, it's always in
12:56someone else's hand. It can always
12:57change at the drop of a look at Claude,
13:00Code, I look at Codex as the first
13:02initial examples, but uh you can see
13:03here with Durable Pi, the kind of
13:05landscape for how you build agents that
13:07keep running without you is going to be
13:09really, really critical. Agents enable
13:11agentic engineering. If you hand this
13:13off to another company that you have to
13:14rely on, you are at a disadvantage,
13:16okay? This is why such a big fan of the
13:19PyCoding agent and of all the work Mario
13:21and Armin are doing here on the PiAgent.
13:23And PyDurable is another stamp in the
13:26ground. It's another show of their taste
13:28as real engineers. There's a lot of
13:30value here and you want to own the
13:32value, okay? And see here, durable
13:34tasks, very powerful. You can do a lot
13:36with this. In our proactive agent, you
13:38can think of the incident response here
13:40as a set of tasks that get walked
13:43through. That's not how this one is
13:44designed, but it's a great framework for
13:46thinking phases in a set within a task.
13:49Shout out to Jev, only 6 cents still and
13:51I'm burning through hundreds and
13:53hundreds of messages coming into this
13:56product. Obviously, this is a mock
13:57product and it's running mock stream
13:59events so I can showcase to you, but
14:01just want to really point out the
14:02reliability here and the low low low low
14:05low spend and average decision time from
14:08Jev. A lot of engineers think Jev is
14:10easy to replace. Try replacing the
14:12spend, try replacing the insane speed,
14:14and then try replacing the reliability
14:15and you'll understand why Jev is so
14:17incredible. Can't wait for their next
14:18models. Let's [music] refocus and talk
14:20about tools inside of your durable pie
14:22agent.
14:27While we look at tools, this is going to
14:28be a great time to showcase another key
14:30feature of durable pie. As you can see
14:33here, I have a network of durable agents
14:35working on different code bases, working
14:37on different problems. They're being
14:39proactive, reading the incoming log
14:41stream thanks to Jev. They're not
14:43waiting for me to work, they're working
14:44for me then waiting. But we can take
14:46this even further. The key piece here
14:48that I really want to communicate to is
14:50we can use multiple clients to connect
14:53to our detached agent. Right? We don't
14:55have the agent running on our device. We
14:57can, and this is the norm for most
14:59engineers. The average engineer right
15:01now is sitting in the terminal prompting
15:02back and forth with their agent in their
15:04TUI or their agent command center, and
15:06it's all on device. But the next stage
15:08isn't that. I can promise you that. The
15:09next stage, the next leap forward, this
15:12way of phase three agentic engineering
15:14requires you to build systems that work
15:16without you, and durable pie is a key
15:18piece of that technology. What do I mean
15:19by that? Let me go ahead and open up the
15:21terminal. I want to show you how
15:22concrete this is. I want to show you how
15:23incredible this is. Durable Py, as
15:25usual, I have just to organize all of my
15:28commands so I can move my agentic
15:29operating level down from the
15:31application and into more concrete
15:33engineering where we can control the
15:35system. I want to use just and I want to
15:38check the net and I want to check the
15:40IDs. Okay, so these are all the IDs on
15:42my durable agent network. And now what
15:44I'm going to do is let's connect to EXC
15:462. Okay, so there's a sandbox that's
15:48running right now in the cloud. J 2E
15:51terminal user interface. I'll run attach
15:53and then I'll paste this ID. So check
15:55this out. I'll open up this device.
15:57These are the same agent sessions. I
15:58want to be really, really concrete here.
16:00I have disconnected my agents from my
16:02user interface. What does this mean? It
16:04means you can use multiple clients to
16:06connect to your agents. This is
16:08important. Why is it important? Say
16:09you're building a product. You have a
16:11classic customer support bot and you
16:13want to make it fantastic. You're always
16:15watching it. You're making sure it
16:16sounds human. You're making sure that
16:18it's really communicating well. And it's
16:20pointing your hundreds, your thousands,
16:21your tens of thousands of users that
16:22reach your landing page every single
16:24day. You want to make sure that it's
16:25giving them value and reducing your
16:26support team's full-on support requests.
16:29You're checking out your agents. You
16:30have your agent running on your website
16:32and then you have a 2E or a browser app
16:35or a durable agent network application
16:37you can jump into to look at the agent.
16:39Okay, so let me show you exactly. Let's
16:40create a new session. I'm going to call
16:41this T002. Watch the left here as I hit
16:44enter. I want the default dir. That
16:45looks great. Let's use the Sonic 55. In
16:47the browser, we have that new agent
16:49created simultaneously this stresses the
16:51point these are clients. My agents
16:53aren't here. They're in the cloud.
16:55They're on my sandboxes where my agents
16:57are running isolated at scale safe. They
17:00have high autonomy here. Let's go ahead
17:01and open this up. Really we just want to
17:02nail this point home and then we'll look
17:04at the tools. So we have this nice 2E
17:05here. Classic command, There we go.
17:08Again, like
17:09>> [laughter]
17:09>> these agents are disconnected. These
17:11agents are operating on my device in
17:13this workspace and this is the agent. So
17:15we have a three-level hierarchy, device,
17:17workspace, agent, and we can connect
17:20with any device. Now, of course, you're
17:22probably thinking about your application
17:24that you're building, right, where
17:25you've opened up your phone and you're
17:26connected to your agent. This is the
17:28spot where you're going to want to use a
17:29durable agent. You're going to want to
17:30disconnect your agent from a standalone
17:34stuck agent instance, a default Pi
17:36agent, a default Claude Code, a default
17:38Codex. We have to give the Big Labs
17:40credit. They've already started moving
17:42on this. You can use Claude throughout
17:44your desktop, through your phone,
17:45through the Covalence app, like there's
17:47several places for this. This is how
17:49they're doing it. They have a durable
17:50agent that operates in some environment
17:52that they can work with. List your
17:53tools.
17:54Let's break down some of the tools.
17:55There you go, it's going to list all the
17:56tools. We have this nice disconnected
17:58client. You can see we have sub-agent,
18:00context searching, right, we have our
18:02durable job checks, application state,
18:04and then classic stuff. Inside this
18:06agent, we can switch to read-only. Every
18:09single tool call, every execution is its
18:11own task. This is something that Pi
18:13documentation calls out directly, right?
18:15Rendell calls us out directly.
18:16Everything the harness runs, from
18:17calling the model to executing a tool,
18:19is a task. Now, this has a very special
18:21property in that you can change it. So,
18:24what do I mean by that? Let's do this.
18:25I'm going to switch to read-only mode,
18:26okay? So, in the UI here, in this
18:28client, you can see we've switched all
18:30the available tools, and now we're in
18:31read-only mode. Okay, so now I'll say
18:33list tools again. I'll do this on the
18:35browser window. It has switched, and the
18:37agent thinks it made a mistake, right?
18:39My earlier list was wrong, it included
18:41tools I don't have. These are the new
18:42tools. No problem, I changed tool set.
18:45mid execution. So, you can see this,
18:46like, even from the agents, like, this
18:47is relatively new. They're not used to
18:49having tools stripped away mid-session.
18:52So, this is a really, really powerful
18:53capability. Now, we're in read-only
18:55mode. We can change our tools on the
18:56fly. This is very powerful, and it's not
18:58just we can change the tools, we can
18:59change really anything about our durable
19:01agent on the fly. Unlike a typical agent
19:04session, where you boot up your agent
19:06session, this is a classic on-device,
19:08in-terminal, single default Pi agent.
19:10That's our tools, we have a variety of
19:12tools here. You know, again, this demo
19:14is going to be fully available to you
19:15link in the description, but you can
19:16just click. You can see the tool
19:18arguments, right? We have list durable.
19:20We have check durable job. We have a
19:22handoff command, which lets you start
19:24fresh model context with a handoff. This
19:26is a classic one. We've talked about
19:28self-compaction on the channel in the
19:29past. This is right in line with that.
19:31But here we have restricted our durable
19:33agents tools to this specific tool set.
19:35So, it doesn't stop there. It's not just
19:37tools we can fully customize. It's not
19:39just tasks and specific phases that we
19:42can restart. We have a shared
19:44application state that all of our agent
19:45sessions can see, can share on our
19:48specific device. In this case, this is
19:50different state. This is state on our
19:52EXC cloud sandbox here. And of course,
19:54we have classic sessions with auto
19:56compaction that runs in the background.
19:58So, you can see all these features
20:00starting to really stack up and create a
20:01compelling story around why Pi durable
20:05is superior to classic in terminal in
20:07your agent center executions. Right? You
20:10can see here I have a fully disconnected
20:112E that is connected to the device, to
20:14the agent wherever it's executing. But
20:15we can go even further than this. One of
20:17the key value propositions of Pi is the
20:20fact that it's extendable. And you
20:22extend them with extensions.
20:26The Pi coding agent has extensions. And
20:28of course, they extend to durable Pi as
20:31well, or Pi durable. New session here.
20:33And we have two extensions we've talked
20:35about before on the channel. We have our
20:37fix smartass Opus. We covered this in a
20:39video where we sat down by hand and
20:41prompt engineered Opus 5 specifically,
20:43but other, you know, really verbose
20:45load-bearing agents that just keep
20:48chatting. And we fixed it with system
20:49prompt engineering. We have this
20:51extension here that we can turn on at
20:52the drop of a button to enable this
20:54specific extension. And we can also turn
20:57on our Jab damage control. This is one
20:59of the 10 levels of Jab that we
21:00discussed a couple weeks back. Jab is an
21:02ultra ultra powerful tool, a generic
21:05classifier with high reliability and
21:07dirt cheap costs that I'm using all the
21:09time now. Check out the 10 levels of
21:10Jeff for agentic engineer after you
21:12finish watching this. That video
21:13absolutely exploded for good reason. We
21:15can turn this on here and now every bash
21:17tool has a Jeff judging if it's a legit
21:19command. Okay, so now we just turn on
21:21those extensions and here's what I'm
21:22going to do. What's in your system
21:24prompt? I just wanted to show me that
21:25this is enabled. Five parts, role,
21:28tools, communication, operational
21:30boundaries, aliases. It has these
21:32aliases that we built in. Again, check
21:34out that video to understand what these
21:35are, but I'll just use one of them right
21:37now. Okay, SCR. There we go. I activated
21:40the alias I created in my system prompt
21:42that condensed my agent's response.
21:44That's fantastic and now we can test out
21:46our Jeff damage control. Let's do an LS.
21:48I have no idea what's in this directory.
21:49Could be absolutely nothing, one
21:51subdirectory. Okay, RM-RF that and we
21:54should get our Jeff command blocking us.
21:57Harness blocked because deletion is
21:58irreversible. Jeff damage control
22:00blocked this. Of course, you can see
22:02it's irreversible, 0.99. Nothing will
22:05restore this. If we want to, we can go
22:07into dangerous mode, we can turn off
22:08this, we can turn off our system prompt,
22:10and then we can re-prompt our agent. Go
22:12ahead, RM-RF that again, and it's done,
22:15right? We turned off our safety control,
22:17we live updated our durable pie agent
22:20with a custom extension. There are a lot
22:22of incredible abilities here. There's a
22:24lot of incredible features for you to
22:26tap into. There are many others here.
22:28There are really powerful commands like
22:30fork to completely fork that agent. You
22:33can see we've created another layer here
22:35where we have a forked agent on our
22:37exe.dev agent sandbox. Say you want to
22:39go a different direction with this
22:41agent. Say you want to ask it a simple
22:44question. You can do that here. You can
22:45fork the context and continue operating
22:48and trying and experimenting and
22:49operating in different directions,
22:51right? Say you want to work on this and
22:53you want to work on that and your
22:54context that you have right now built up
22:56in your context window is exactly what
22:58you need at this certain point in time.
23:00So, forking, very very powerful, very
23:02obvious capability that you're going to
23:03want. This is built right into the
23:05fabric of Durable Py. You can fork with
23:08the state. You can start over with a
23:09fresh conversation, or you can run a
23:11fork at any point in time. Extensions,
23:14tools, it's all here. What we've done
23:15here in this code base, in this kind of
23:17Durable Py agent network, is create a
23:19real concrete example of what this looks
23:22like. Put your agents on their own
23:24devices, let them scale safely in
23:26isolation to gain autonomy, let them
23:29operate like you can by giving them the
23:30tools you have. And then it's about
23:32building up the agentic tooling around
23:35it. In a way,
23:37uh this is advanced harness engineering.
23:39That's really what's happening now.
23:41We're really thinking through where the
23:43harness is, and we're even wrapping that
23:44in bigger layers of abstraction, right?
23:46We have different devices, we have
23:48different tooling, different extensions.
23:50We can run tasks with this agent harness
23:52in a repeatable, resumable way. There's
23:55a lot of value coming out of this tool.
23:58And our proactive agent, looks like we
23:59got another incident here.
24:01Cart API anomaly warning. You saw here
24:04that proactive agents are available now.
24:06These are agents I really implore you to
24:08start building out. First off here, let
24:10me give a lot of credit to Armon and
24:12Mario. Everyone can generate code now,
24:14not everyone can software engineer. This
24:17is a clear, a dead clear example of it.
24:19What they wrote here is some 15,000
24:22lines of or 10,000 lines, I don't
24:24remember where they said it, but you
24:25know, it's some thousands lines of
24:26TypeScript code. If code is so cheap,
24:28why is this an incredible product that
24:30thousands, tens of thousands, hundreds
24:31of thousands of engineers are going to
24:33use, myself included. And I'll talk
24:34about exactly how I'm using Py Durable
24:37in my work in just a moment here, but I
24:40just want to give huge credit to them.
24:41This release is a showcase of taste,
24:43judgment, and decision-making. That's
24:45what software engineering really is.
24:46It's not code. Coding is now, and was
24:49before frankly, for most of us,
24:51the easiest part of the job. The hardest
24:53part is deciding what's valuable. It's
24:55knowing and having the judgment, and
24:56specifically the expertise to know what
24:59to build in the first place. It's dead
25:01easy to copy another tool that's
25:03innovated or another model that's
25:05innovated or another product that's
25:06innovated, but it's much harder to strip
25:09everything away except for the one or
25:11two things that your expertise tells you
25:13this is what really matters. This is the
25:16product. This is the value. Okay, and
25:18that's what pie is. Pie durable is the
25:19same. Big shout out to Rendell and Mario
25:22and Armen for really building out a
25:23great product. I'm really really looking
25:25forward to a V1 uh stable release of pie
25:28durable. I know right now it's
25:29experimental, so uh I can't really
25:32deploy this in the production um unless
25:33I want to fork and maintain it, which I
25:34don't. So, I'm really looking forward to
25:36the official release from them. Big fan
25:38of this. Let me just break down really
25:39concretely why should you use durable
25:42agents? If it's not clear, let me just
25:43like really walk through why should you
25:45use durable agents? First off, you can
25:47build proactive agents. This is the
25:50future of engineering. I'm fully betting
25:52on that. The entire phase three product
25:54that I'm building right now is built on
25:56this idea. And proactive is really not
25:59selling the full vision of what I'm
26:01building in the phase three agentic
26:03engineering product for you. Again, link
26:04in the description for that. Definitely
26:06sign up. Pre-sign up is going on right
26:07now. Soon it'll be pre-sell and soon
26:09it's going live. Proactive agents are a
26:11piece of that future. You want your
26:12agents to start working for you without
26:14you so that when you show up everything
26:16is already done. And even better, if you
26:19are approaching ZTE, zero touch
26:21engineering, it's already done. And all
26:23you're doing is reviewing the how and
26:25every once in a while you're fixing the
26:27issues that your agent rolled out, but
26:29everything else will be smooth sailing.
26:31Okay, proactive agents, as you saw here,
26:33is a very very valuable way to deploy
26:35out-loop agents that work without you
26:38right now. Take this example, put it up
26:40against your production logs, put Jev
26:42right in front of it. You can see here
26:43this whole time I've almost been filming
26:44for a full hour now, but you can see
26:46here this whole time only 13 cents to
26:48categorize all my logs to find
26:49production issues for you. To find
26:51production issues and trigger an
26:53incident response agent that runs a
26:55dedicated AI developer workflow that
26:57runs steps you used to run yourself as
27:00the incident responder, right? The
27:01engineer on call. There is more and more
27:03work you do not need to be doing if you
27:06invest into your agents, if you invest
27:08into Harness engineering, if you invest
27:11into a tool you can fully control. Open
27:14source, controllable, extensible. The Pi
27:16coding agent, I keep talking about this
27:18tool for a reason. I'm not sponsored. I
27:20don't accept sponsorships on this
27:22channel, so I stay unbiased. The only
27:24thing I'll sell you on the channel are
27:26products I create by hand for you, for
27:28the mid to senior cracked engineer
27:30shipping to production, okay? But I just
27:32want to make this super clear. For the
27:33longest time, engineers thought I was
27:34sponsored by Cloud Code when I was
27:36talking about them all year last year
27:38before it became mainstream and hype.
27:39Now I'm talking about Pi. Why is that?
27:41It's because you want to control the
27:43most important technology available to
27:45engineers, the agent. How do you do
27:47that? With an agent Harness. How do you
27:49do that best? With one you can control.
27:51Proactive agents let you use this new Pi
27:53durable abstraction to start doing work
27:57for you without you, so that when you
27:59show up the job is near done, right? And
28:01you are human near the loop, or like a
28:03lot of the tactical Agenta coding
28:05members and now the next phase three
28:06product. If you've taken [music] these
28:08products, if you know where I'm coming
28:09from on the edge, if you're advanced,
28:11you are probably already letting your
28:13agent ship to production. I really did
28:15not add any value here. If you think
28:17about value I added, I added basically
28:19another safety check that was completely
28:20redundant. We've talked about on the
28:22channel many of the ways to increase
28:24your review velocity to make sure
28:25everything is legitimate. We're going to
28:27be talking about that a lot more. There
28:29are really two constraints of Agenta
28:30coding. It's planning and reviewing.
28:32Both of these are now completely
28:34solvable. That's unrelated to Pi durable
28:36or durable agents. This is just with
28:38great Agenta coding and its subparts,
28:41prompt context Harness engineering. Both
28:43those constraints are solvable. Again,
28:44that's what we're going to be talking
28:45about in the phase three product for
28:47Agentic Engineers. Link in the
28:48description. Do not miss that. The next
28:50big leap is coming, and this one's going
28:52to be hard to follow because once you
28:54start on this leap, you're going to keep
28:55jumping, all right? Double jump, triple
28:57jump, quadra jump, infinite jump, okay?
28:59Productive agents, I've talked about
29:01that enough. What else? We have
29:02multi-client agents. I kind of showcase
29:04this, but once you do this, once you set
29:06up your agent API for your personal
29:08engineering work, but also for your
29:10product work, you get this really
29:11powerful single API every client
29:14interface. So, you have your browser,
29:16you have your custom command line
29:18interface, you have curl. So, like you
29:20can just take an agent and say, "Here's
29:22the API for my agent devices, for my
29:24durable agents, for my durable agent
29:26network. Fire up agents, solve these
29:28problems, okay?" So, this is all very,
29:30very real, and it lets you extend this
29:32capability one more time. The common
29:34ones here, it's your browser, it's your
29:35command line interface, it's raw HTTP
29:38requests via curl. If you have your
29:40right authentication, your tokens set up
29:41properly, it's also your mobile device,
29:43it's your product. Right? A lot of what
29:45we're doing, you know, don't forget
29:46this, it's all for your users, it's all
29:48for your products you're building. UIs
29:50in the browser for your company, for
29:52your product. And then, of course,
29:53there's a bunch of engineering-related
29:55agents you can set up that don't even
29:57need an interface. They just working for
29:59you in the background. And that also
30:00brings up this new paradigm of
30:02multi-player agents, okay? So, this is a
30:05more popular, more obvious one, but with
30:07this, it's not just you that can
30:08connect, it's your co-workers. Your
30:10co-workers can connect to this incident
30:12agent. You can have a couple engineers
30:13on call review the logs together, you
30:15can prompt your agents together. This is
30:17the new cool hype thing happening right
30:19now from all the big AI labs. I care
30:21less about multiplayer, and I care more
30:23about long-running agents. You can close
30:26the laptop, you can refresh. These
30:27agents are just not going to stop. So, I
30:29can just refresh this, it's just going
30:31to keep loading back up, right? There's
30:32my fork agent, there's my root agent,
30:34here's my main agent, and these are all
30:35working on different products, different
30:37services you have up and running on
30:38their durable agent sandboxes running
30:40their own durable agents, right? These
30:42are long-running. Close the laptop, kill
30:44the process, restart the machine,
30:46they're going to come back and work from
30:47their last checkpoint. Definitely do
30:48some testing around this so you can
30:50really understand that you can kill the
30:52agent, right? You can completely
30:53interrupt its workflows, and they come
30:55back, okay? And, you know, another key
30:57value prop is human near the loop. I
31:00fully recognize that it's hard to jump
31:02directly out the loop
31:04from in loop to out loop if you've been
31:05stuck in the terminal forever. That's a
31:07process. Agentic engineering is a new
31:09skill. It's not something you just pick
31:10up and start doing. Durable agents
31:12unlock human near the loop. Very, very
31:15powerful, very important. You can
31:16approve workflows, you can approve the
31:18deploy, you can do a little bit of
31:19review. You stay in control of what
31:21ships. These are kind of the big reasons
31:23to go durable, right? Proactive agents,
31:25multi-client agents, multiplayer agents,
31:28long-running agents, and human near the
31:30loop. How am I adopting durable agents
31:33like the Pi durable release? How am I
31:36actually rolling this into my work? It's
31:37pretty simple. All product work, I'm now
31:39going to use a durable agent by default.
31:41So, if I'm building any products, the
31:43simple example is a support chatbot on
31:45the front end of your site. That should
31:46be a durable Pi agent. There's no reason
31:48for that not to be. Your user can come
31:50back to the existing session it had. You
31:52can clear it after 6 hours. You can do
31:54whatever you want with these durable
31:55Pis. This is really powerful. I'm also
31:57investing heavily into proactive agents.
31:59This new class of agents that I can tell
32:02you now, proactive agents are the agents
32:04of the future. They don't wait to work
32:05for you. They start working for you, and
32:08then they wait for you to approve.
32:09Right? Proactive agents, where they
32:11start prompting you. I'm heavily
32:13investing into these so that they start
32:15doing work before I show up, okay? And
32:17this continues on that massive trend for
32:19agentic engineers that we talk about all
32:21the time on the channel, stay out the
32:24loop. This is a central idea inside of
32:26the second phase course I put out,
32:28tactical agentic coding. Phase three is
32:30going to compound and build on this like
32:32no other. The more work your agents can
32:34do for you without you, the more you are
32:37actually a gentic engineering and not
32:39just a gentic coding. You don't want to
32:41be sitting there babysitting your
32:43agents. You want the agents to be
32:44working for you without you. Outloop is
32:46the next leap. Again, get on the
32:48pre-email list for the phase three
32:50product. I can't wait to share more of
32:52that with you. Early sign up is linked
32:53in the description. I've also got
32:55durable pie linked in the description
32:57for you. Both the network demo and of
33:00course you'll have to set up your own
33:01devices here, but it should be pretty
33:02straightforward. I'll make sure all the
33:04documentation is dead clear for you and
33:05your agents. And then I'll also have
33:07this proactive agent demo for you just
33:09to get your head turning on how to build
33:12this out. I really wanted to create
33:13something concrete that you can use to
33:15really understand how important durable
33:16agents are. This is a real use case that
33:18can give value to you and your
33:19customers, that can give value to you
33:21and your engineering organization right
33:23now. You can see 6,000 rows, 16 cents.
33:26We've got Jev in here doing real
33:28engineering work for us, classifying our
33:30log stream of every event coming in. You
33:32can improve on this in many ways. If you
33:34just want to do a simple stream check on
33:36the status and then skip it, great, do
33:38that too. You can skip Jev there and
33:40only look at your 4XXs or your 5XX
33:42errors, right? This is just the
33:44beginning, it's just a template. I've
33:45got this linked in the description for
33:46you to help you move fast on this
33:48opportunity before it becomes mainstream
33:50proactive agents, outloop agents. One
33:53day this is going to be the norm and
33:55you're here, you made it to the end,
33:56you're watching this. You have this
33:58value right now. Information you don't
34:00act on doesn't matter at all. You know,
34:01please make this useful. Please make all
34:03my effort here
34:05useful. I'm putting this together for
34:06you so that you can get this next
34:08massive advantage. A great KPI of
34:10success that I recommend for every
34:12agentic engineer is this. How many
34:14agents are doing useful work for you at
34:16any point in time? And I'm not talking
34:18about sitting down, kicking off work,
34:19kicking off huge jobs. That's the phase
34:21two mindset. You are responsible for the
34:23kickoff. Think phase three. Think agents
34:26that start without you. Think agents
34:27embedded into the fabric of your work.
34:30And durable agent is a key part of that
34:32story. Durable agents ultimately
34:33increases the number of agents that can
34:35accomplish work for you both in loop,
34:37out loop, and then near the loop. And
34:39right now, here at the end of 2026 and
34:42in 2027, the key is going to be making
34:44that transition from in to out. Okay, so
34:46if you're here watching this, you have
34:48very, very valuable information. I don't
34:50care what anyone says. This is where
34:51it's all going. I've seen it, I've done
34:53it, and I'm going to share more of that.
34:54[music] Get started with the Pi Durable
34:56Demo. Shout out Mario and Armen, and
34:59shout out every engineer that made it to
35:00the end here. If you enjoyed this or
35:02learned something, make sure you like
35:03and [music] subscribe to stay connected
35:05to valuable agentic engineering
35:07information like this. You know where to
35:08find me every single Monday. Stay
35:10focused and keep building.

About this transcript

This page contains the full transcript of Pi Durable PROACTIVE Agents: Jev Triggers My ON-CALL Pi Agent by IndyDevDan, generated from the public captions YouTube serves with the video. The transcript has 7,382 words across 1,073 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.