[00:00] Look, AI agents make fewer mistakes than you or I on our best days as engineers. Don't take my word for it. Give Opus 5.5 a hard task and read the trace. Seriously, read the trace.

[00:11] It now looks like an alien engineer running the most obscene bash commands and tool-call combinations. And it's not a one-off. Opus and Astra do this back-to-back-to-back.

[00:22] You and I are smart. So let's ask smart questions. If the agent is a better programmer inside the loop, why are you still sitting in it?

[00:31] Recent intelligence has unlocked a new level of capability that the best engineers are obsessing over. If you want to know what this new level is that you can unlock, you're watching the right video.

[00:42] I've been working with language models and agents since it was first possible. Before that, I trained classic scikit-learn models. I have 15-plus years of software engineering experience underneath all of it. And that's exactly why I'm telling you this: experience doesn't auto-unlock this new level in the age of AI. Your experience pays off if you change how you operate.

[01:05] Not all of us will make this leap. Why? Because we're doing things the way they were done yesterday. What are Opus, Astra, and DeepSeek? These are new tools. Nothing more, nothing less. But stack enough of them in the right architecture, and you can change what's possible by changing how you operate.

[01:22] And you've been doing this. Instead of writing the skill yourself, you taught your agent how to write your skill. Meta-skills, check.

[01:29] Instead of running 10 agents yourself, you ran one agent to prompt nine. Orchestration, check.

[01:34] Instead of being stuck in the loop, realizing you can build the system that builds the system. And this begins the critical journey from human-in-the-loop to near-the-loop to finally out-the-loop.

[01:46] That's the central topic for this video. I'll show you three of many near-loop agents I'm running right now that do real work before I sit down. And by the end of this video, you'll know exactly how to level up your agentic engineering. Stick around, and let's understand in-loop, near-loop, out-loop.

[02:08] What if your agents never stopped?

[02:14] The big question is: What can run without you next? This is the guiding question. This moves us from in-loop to near-the-loop to out-the-loop. We are constantly building the system that builds the system. That's the theme here: prompt, click, cron.

[02:27] What do I mean by this? Let's break it down.

[02:29] When you're in the loop, it's you and the terminal. You're constantly applying your attention to write prompts.

[02:34] When you're near the loop, you're clicking. You're responding. You're giving advice. You're giving feedback.

[02:40] When you're out the loop, it's full cron. You have stepped away. You are not a requirement anymore. And this is the new mental model for understanding your agentic engineering skill by the results you can achieve.

[02:51] If you're improving, you're building more systems that don't need you in the loop. You're building more near-the-loop systems and more out-the-loop systems.

[02:59] So why is in-the-loop such a problem? Let's talk about it.

[03:02] What's wrong with being in the loop? The problem of being in the loop is that you and I, as you know, are the limitation. You and I are now the bottleneck. Our agents can do so much more if we have the right skills, if we have the right tools, technology, and if we're operating the right way.

[03:17] This threshold, this new level of capability, requires you to change how you're operating because you and I are the bottleneck. And the hard truth here is 80% or more of all the work we're doing right now can run without you, can run without me, with the right system in place.

[03:33] So the next question is: What is this system? And what is this way of thinking? And as you know, you know, based on the title, it's out-loop.

[03:41] But then another problem arises very quickly. Jumping right from in-loop to out-loop is hard. So what do we do? We create this middle step, this transition in between fully required, butts in seats, you using all your attention on the next prompt, you watching your agent. Jumping straight to out-loop is hard and challenging. So what do we do? We move near the loop.

[04:01] We incrementally work towards the future we want to create, where systems can operate for us without us by first stepping away and then stepping in when we're required.

[04:10] So the big difference is: Are you being proactive or are you being reactive? You want to be proactive. You want to build systems that start working for you before you sit down.

[04:20] And we've been covering these on the channel week after week, but it looks like this: Instead of you being the trigger, you have a concrete event. Think web hook, think cron, think user action in your interface, think Jev classifying an event from your log stream. There are a million other ways to kick off your agent. Why are you still the main one?

[04:41] That's phase one and phase two agentic coding. That's in-loop. That's yesterday's advantage. That's fully saturated. You want to switch to thinking about proactive agents, proactive agent systems. The thing that they need kicks them off.

[04:56] If you haven't figured it out yet, the thing they need isn't you. It's information, and it's the right information. And that's the job now of agentic engineers: get the right agent the right information.

[05:11] Why do this? Who cares about proactive agents? Why am I bringing this up on the channel for the third time in a row? It's because work happens before and after you check in. This is the result of investing, putting time in, and creating a system that only requires you to be near the loop, okay? Which is substantially different than in-the-loop, but it's still close enough that it doesn't feel super disconnected.

[05:31] Let's walk through a real use case. A classic one we've been looking at is: some event comes in to your event stream, to your log stream, triage happens. You'll use Jev to classify the event, you prepare the patch, and then your agents present it to you. This is where you check in. You make a concrete decision, and then, guess what? You can walk away because you've already built it into the system what happens next, right?

[05:48] You have an AI developer workflow executing on your behalf. Detect event, triage, patch, ask, apply the change, verify the change, results saved. This is human near the loop. Work happens before and after you check in. Very, very valuable.

[06:01] So what are the core elements you need to understand to build these near-loop systems? Again, themes on the channel: we've been talking about these week after week after week because they matter so much right now. This is high-signal information. Durable agents is the first item.

[06:15] Why do we need durable agents? Why can't we just throw classic Pi, classic Claude Code, classic Codex at this problem? It's because we need to survive crashes, restarts, closed laptops.

[06:23] Speaking of closed laptops, the big up-level here is a classic theme that's permeating throughout the software industry: you want to put your agent in their own sandbox. You want to give them their own CPU compute and, for the labs, also GPU compute.

[06:37] Why is this? It's because they're always on, it's isolated, it's safe if you're sandboxing properly, and, most importantly, it's autonomous. You're scaling your agents into their own environments where they can perform like you because they have all the tools you have, and the most important tool is a full computer.

[06:53] So that's not it. This doesn't make a near-loop agent. You need something else. You need a clear API layer so that you can connect a variety of triggers to actually activate the system.

[07:03] Again, there are a million ways to kick off your agent. Why are you still the main one? Asking yourself that question, it lets you design the system where you can move from in-the-loop to near-the-loop.

[07:14] And they're all exactly what you'd expect: cron triggers, log events, tickets, right? User interfaces, drag and drop, image events, and then, of course, CLI agents working on their own time, doing their own thing, kicking off your near-loop system.

[07:27] So this is what it takes. These are the core elements of a near-loop system. This creates something really powerful once you build it out.

[07:35] The thing that really makes it a step-change, a level-up in your capacity, is that a durable agent plus a trigger in a sandbox gives you a proactive agent. This agent does not wait for you to work; it works for you, then waits. This is a massively different level of engineering results you can achieve now with this architecture.

[07:53] Try to have a vibe coder vibe code this, they won't be able to. That's why Grok bot, that's why Dots, that's why Claude's co-work and all their infrastructure exists. It's because they're trying to commoditize this for the average user and, frankly, for some lazy engineers. That's okay if you're one of them.

[08:09] I will say, though, this is technology I highly recommend you own because this is going to be a key part of what it means to engineer massively leveraged results in your favor.

[08:18] Again, durable agents persist. This is what makes them so powerful. They persist, and that means that they can ask you things, they can survive restarts, and then they can get the job done fully. But they need to be keeping track of everything in a repeat basis. Durable agents require memory. Your normal in-the-loop agents will not cut it for systems like this. I hope that's clear.

[08:43] Once you get these up and running, they become really powerful. So incident response agent, this is something we covered on the channel. An incident comes in, your agents then run a clear-cut AI developer workflow, a workflow that you used to run yourself, a developer workflow. If you're the incident response engineer on call, you detect, you investigate, you root-cause analysis, you fix it, and then you prep for review.

[09:03] The difference is now you can build a proactive agent inside a near-loop system to do this on your behalf, and then guess what? You are then just the reviewer. You review the fix, and then you deploy it.

[09:13] This is not pie-in-the-sky information. This is what we cover on the channel week after week. Here's a real UI that we looked at for a mock example of what this system looks like. It's a disconnected client with streaming events. We're using Jev to classify the events, and then our on-call agent found the issue, and now all you have to do is understand and click deploy.

[09:31] I've been talking with many engineers. They are actively rolling this out right now because the value prop is there. Proactive agents can give you value right now. This is real; this is tangible. The agent worked through the AI developer workflow, it waits for your approval, and it is using Jev to judge every single row.

[09:49] There are improvements to be made here. If you're not getting 4xx or 5xx HTTP error codes, you don't need Jev for that. What you do need Jev for is to classify the information very, very quickly to understand based on your system if it's an issue or not.

[10:02] Okay, so that's a real example. What else? How else can you use proactive agents?

[10:05] Last week, we covered using Jev to filter out hype, to analyze facts, and then to filter in signal that we actually care about: information you can act on. Many engineers, you know, many content creators, YouTubers, posters, media, they just hand-wave and talk about this stuff.

[10:24] I like to hand-wave, literally, and talk about this stuff, but I also like to prove it so you can better understand what's happening and what's possible, so you can go beyond what your competition can do, so you can actually act on this information.

[10:37] We have done this. This UI is real, and I can pull it up right now. This is on a sandbox, and this one's actually on my M4 Mac mini right here. If I go to IDD agents, there we go, hit enter here, you can see that this is a durable agent that's on all the time. It's working for me, and then it waits for me.

[10:52] This has been on for a week and a half now. I keep it on all the time. I'm not going to turn it off because it's constantly providing me value. I can hop in here, ingest the news at lightspeed. Information is getting pulled to me. I'm not getting clickbaited into anything because I'm normalizing how I want to see the information in a non-biased way.

[11:08] Again, check out last week's video where we covered the durable news agent. But you can see, you know, real concrete example. This is stuff I'm building against right now. This is stuff I am working with engineers to build all the time.

[11:19] You can see here, LoomCycle, decision model scores 40 out of 40 on prompt injections. Interesting. I'm going to upvote that. I'm going to give signal to my proactive agent so that it continues to prompt me with questions it has and continue to reinforce the data flywheel I'm building with this kind of micro-product.

[11:36] This is a key distinction. The best engineers are moving from building individual engineering agents to really product agents that focus on a specific use case that outperform the default by miles.

[11:47] So this is one of many near-loop systems that I'm building aggressively right now because, again, it's going to work for me without me, and then I'll come in, I'll extract value, I'll give feedback, and it's going to improve. Real concrete result.

[11:59] Let me show you another one that I haven't revealed on the channel yet. This is new since the Jev 1.14 was released. I am dropping in UI designs, I'm dropping in mock designs, and then a primitive RSI loop is running that's going to build against the mock and compare over and over and over until the UI matches the mock design I passed in.

[12:20] It looks just like this: fix, build, screenshot, Jev. It uses two or more agents optionally. We're just looking to pass a similarity threshold for the UI, okay?

[12:28] And, you know, I can show this to you, right? This is real, called the Deep Jev UI Replicator, and you can see here I dropped in a screenshot of the Phase Three agentic engineering product. I'll talk about at the end. You can see it's looping, it's hill-climbing on this objective that I gave it, and it's just working and working and working.

[12:45] I can change the model, I can change comparison agent, I can tweak the core four of this system. You can't build these systems without understanding the core four: context, model, prompt, tools. We'll talk about that in a second.

[12:56] Key skills to know and to learn. Again, a lot of channels, they just try to newsjack. This is real content, real ideas that we talk about every week on the channel. We are putting these ideas into action to generate real value, real alpha.

[13:09] Let me show you exactly what I mean. Bam, here it is. This is on a cloud sandbox, so this is not local anywhere. This is in the cloud, but you can see here, I had Astra mirror this UI. It got a 86.1 match. I just drag and dropped an image in, and it looped over this.

[13:23] You can see I have another one here. Let's go to another example here, mirroring the Phase Three landing page. You can see, slowly hill-climbed toward this, got a decent result here after iteration three, and then it failed to mirror even further. Okay, this was the Sonnet 5.5, so not bad.

[13:38] But you can see here, you know, again, it's a system that delivers me concrete results. I can come in, ask for something, and then leave. I walk away while it works. It takes, you know, some 30 minutes for all these iterations to run to basically recursively work toward an example.

[13:52] These are all big ideas, big themes we're talking about on the channel all the time, week after week. The next leap is here, and I'm going to do my best to communicate it to you, the mid- to senior-plus-level cracked engineer. This is where it all leads: these powerful systems.

[14:07] Let me make it super clear once again that these are just clients. Like when I connect to the browser, I can connect to some of these via my terminal or my phone, and they're all backed by some sandbox because, again, proactive agents are always on. They don't turn off.

[14:21] Just like when you walk away from a session at the end of the day, you close your Claude Code, you close your Codex, you close your Pi, it's done. The value you can get when you build a system like this is immense.

[14:32] There are other new next-level problems, you know, next-generation bottlenecks emerge. But right now, the goal is to move from in-loop to near-loop to out-loop. And so the sandbox architecture is really, really important. You do not want your agents to be limited by your device.

[14:53] Why do we build these durable agents? These agents persist on the device. Why do we need them?

[14:58] First off, they can be proactive. They can start working before you show up, before you wake up.

[15:02] They're multi-client. Again, browser, terminal, phone. Anyone anywhere can connect to it. This is really important for products.

[15:08] And then, of course, multiplayer. You, product, design, support, if you build and you give them the right tool, they can hop into the right agent to get the work done much, much faster than they would otherwise.

[15:18] Long-running. Durable agents survive crashes, they survive restarts, and they have to. They have to have this property.

[15:24] And then finally, all this builds up to the fact that this lets you move near the loop. It removes the seat from underneath your butt, okay? You don't have to be sitting in the dev chair. And this is a big unlock. I hope that's clear.

[15:37] So what are the essential skills to learn? It's the essentials. Again, this is like our bread and butter on the channel: context, model, prompt, tool. This is the measure of how far you can move out.

[15:46] You know, we've been talking about this for literally years on the channel: context, model, prompt, tools. It all comes back to this. The agent is made of these four. And you've heard of all these skills. You've learned and expanded on your abilities. Most engineers, most content creators, most people talking about agents, they're just focused on this.

[16:04] This was a lot of the earlier channel videos. We've moved up a lot from this stuff. Sometimes we jump back in and cover, you know, some system prompt engineering or some context engineering trick or maybe we'll cover a model if it's interesting enough. But really, these are the new lower-level primitives.

[16:18] The one that's really worth a lot of attention and time when you move to the mid and advanced levels is really harness engineering because it starts to move and wrap this powerful intelligence in a system that can outperform the baseline and do really unique things.

[16:32] This is why I constantly talk about the Pi coding agent and Pi durable. It's because there you can really expand and give your agents more actions and customize the results they can get. Specialization is the advantage, and a lot of engineers are really noticing this as everyone, their mom, their brother, their sister, their dad, can prompt and build a, air quote, "application," right? Or reverse engineer anything.

[16:55] The advantage then becomes: How can you specialize your results? How can you build a system that can do what others could not do? And this is where software engineers have a huge advantage.

[17:04] That's the big idea. Mastering your context engineering, your tokenomics for the model you're selecting, it needs to be performant enough to get the job done, but not so expensive that it breaks the bank. These insanely subsidized subscriptions will not last forever, so understand tokenomics. Shout out, DeepSeek.

[17:20] Then of course, prompt engineering. It's how you instruct your agent in the first place. If you can't write a great system prompt, if you're stuck relying on the defaults, it's going to be really hard for you to move near-loop and out-loop. You must understand both the user prompt you pass in all the time and the system prompt that changes the law for your agent.

[17:37] And then, of course, the tools, the harness. This is a big one. And these all make up the core four. You must learn these skills to transition out the loop, otherwise you'll be stuck at the lowest level because you'll be relying on whatever the out-of-the-box Claude Code, the out-of-the-box Codex, the out-of-the-box experience of the agent harness, the out-of-the-box results that everyone else is now receiving.

[17:58] Again, the advantage of a single agent in the default configuration is completely saturated. It's been that way for a while now. Everyone's relying on the models to improve this. That is just one dimension of four that you, the engineer, can tap into to multiply your leverage.

[18:13] Agentic engineering is understanding these four: your context, your tokenomics, your prompt, and your harness engineering. And the big thing that I think the industry is really losing their brains over right now, and viewers of this channel understand deeply, is that all this is multiplied by your software engineering because this is what you know. These are the questions you can ask. These are the architectures you can build. This is the expertise you have in your domain that you've been building up year after year.

[18:39] The value of this cannot be overstated now because you can now use the rest of these items. You can now use these new paradigms to multiply, and I really mean multiply, what you can do. I know it's so cringy just throwing out phrases like multiply, exponential, parabolic, but it's true. It's factually true.

[18:56] And this is available to you because you can use these powerful new intelligent tools and then apply your knowledge in context, in the tokenomics, in the prompt, in the instructions, and in your harnesses.

[19:07] The gap for engineers truly upscaling their agentic engineering has never been higher. As I always say: Vibe coding is the floor. Agentic engineering is the ceiling.

[19:16] So what do I mean by this? Let's be super concrete.

[19:18] So you select a specific model at the right cost, performance, speed tradeoff. You then build a custom agent harness using whatever SDK you want, I recommend Pi. This enables you to start harness engineering specific tools to generate specific results for your product or application.

[19:33] You then realize that your agent could start firing off some negative commands. So what do you do? You add a Jev damage control. Maybe you get rid of the bash tool entirely because you realize how dangerous it is, and you just give your agent exact results it wants. This is agentic engineering.

[19:48] This is a concrete example of you applying your expertise, your awareness, your understanding of security, of your product, right? What your product needs, your understanding of model selection, tokenomics, harness engineering, you passing in the right prompts to this system. These are skills that make up agentic engineering. This is how you move from in to near to out.

[20:09] You build these systems so well, you don't have to look at what they're doing. That's the key.

[20:13] Again, not to flame or rip on all my vibe coders that show up, you know, shout out to you guys, but vibe coding is not knowing what your system does and it's not looking. Agentic engineering is knowing what your system does so well you don't have to look. The difference is massive.

[20:28] This is what it looks like: you are building the application layer, you are prompting your agent. We want to move to this new paradigm where you build the system that then builds the system on your behalf. That's the target.

[20:36] This is what it looks like: build the system that builds the system. This is the guiding phrase I use for Tactical Agentic Coding, the phase two product I put out a year ago now, which is still relevant, by the way. But the third phase is coming, and this single phrase still holds true.

[20:52] And so here's the measure of your success now. You can use this as a concrete model, concrete framework I'm recommending for engineers. This is something I'm obsessing over right now: your measure of success is how many agents are working for you right now, right now in this very second.

[21:07] Now, obviously, I'm not talking about token maxing. Anyone can spin up a while loop and have an agent just do random shit. I'm talking about useful work that you need to get done, and this stuff is happening, right? I'm talking about useful work that can multiply your abilities in ways that you understand, in ways that you might not have foreseen yet.

[21:24] I'm talking about products that you've built with agents inside running for you without you. I'm talking about near-loop and out-loop. The advantage is very clear: you can only focus on so much. You can only split your attention across so many terminals before you lose your mind and lose focus.

[21:39] And now all these three threads have turned into three threads where you have no idea what's going on. You're just trusting the model more and more. That is not engineering.

[21:46] Engineering is building systems that you reliably know what they'll do to get the results you're looking for. This is the measure now. This is the move from low-leverage agentic engineering to more leverage agentic engineering to high-leverage agentic engineering.

[22:01] You build the system that is built so well you step away because you realize you are the bottleneck.

[22:08] The next leap is here. If you've been with the channel week after week, month after month, you know what's coming next. Phase Three is the deprecation phase. Augment, automate, deprecate. This is the three-stage cycle of every technological revolution.

[22:19] This is where we employ ZTE, zero touch engineering. If you've been with the channel, you know what I'm going to do next. I'm going to pitch the next Phase Three product that I'm building right now for advanced engineers using agents every single day. Link's going to be in the description for you.

[22:35] In Phase Three, we focus purely on out-loop agentic engineering. This is the next leap. The thing to master is going to be all the fundamentals so that you can deploy them into these systems that, again, work for you without you. Link in the description for that.

[22:49] Pre-sale starts soon, and throughout pre-sale, I'm going to be offering a huge discount on the product. And if you're a Phase Two Tactical Agentic Coding member, you'll also receive a large discount on the product. I'm so, so excited to share this with you. It's coming along really, really well.

[23:03] What is this transition? Why is this so important? We're moving from in-loop, where you prompt, to near-loop, where you approve, to out-loop, where you observe. This is the key flow. This is the progression for agentic engineers now.

[23:16] So how do you actually do it? How do you move out the loop? You master the core four. You master what makes up the agent. You use durable agents to solve real problems. This agent keeps running. It's looking for triggers. You build systems that build systems.

[23:29] This is the key thing that software engineers can do that no one else can. It's always been this way. But now it's clearer than ever because the leverage is higher than ever.

[23:38] And then like and subscribe. Stay connected to valuable information, to engineers actually doing the thing, not just covering the news, not just covering the new model release with the shocked MrBeast O-face thumbnail, right?

[23:51] Like, this is our bread and butter on this channel. I've been here four years covering this week after week every single Monday for years now. And guess what? I'm going to do it until the end with you because this is the most incredible opportunity that has ever existed for us engineers.

[24:07] Maybe you missed the internet revolution, maybe you missed the mobile revolution, maybe you missed social, maybe you missed crypto. You and I are here right now in the age of agents. Let's capitalize on this. This is what we focus on every single week here.

[24:19] Again, like and subscribe. Join the journey. Tell the algorithm this is signal for you. I've got three really important links for you in the description. Pre-sign-up for the Phase Three product. If you use agents every single day, if you understand this advantage, if you're an advanced user of agents, that's going to be for you.

[24:35] If you don't fall into that bucket, I'm sorry, this product is not for you. This is going to be the most complex course, the most complex product for engineers I have ever created, and the most valuable. So that's linked in the description.

[24:45] And then I have previous week's video where we talk about and break down two real durable agent use cases. You saw us cover here: the durable news agent and the on-call agent.

[24:53] Over the next month, leading up to the release of the Phase Three product, I'm going to be sharing content directly from the Phase Three products just to give you a teaser of what's coming next, to really paint the picture of what you can do and what's inside the product so you can know what you're getting so that you can hop on the discount.

[25:09] I want to reward engineers that move fast and invest in themselves. So again, link in the description for that.

[25:15] It's going to be you or your competitors that make this leap, and I want it to be you.

[25:19] Whenever you sit down in the terminal, when you put your butt in the seat, I want you to really stop and ask yourself: Is there a reason I'm still in the loop for this work? And the answer should truly only be yes if you are building the system that builds the system.

[25:33] Comment down below if this all makes sense to you. Thanks for watching till the end. I'm going to be with you here till the end. You know where to find me every single Monday. Stay focused and keep building.