ELITE Agentic Engineers Are LEAVING THE LOOP... Here’s why

0:00Look, 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. 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. 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? 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

0:39you can unlock, you're watching the right video. 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

1:01pays off if you change how you operate. 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. And you've been doing this. Instead of writing the skill yourself, you taught your agent how to write your skill. Meta skills, check. Instead of running 10 agents yourself, you ran [music] one agent to prompt nine. Orchestration, check. Instead of being stuck in the loop, realizing you can build [music]

1:37the 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. [music] That's the central topic for this video. I'll show you three of many near-loop agents I'm running [music] 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 [music] engineering. Stick around and let's

2:00understand in loop, near loop, out loop.

2:07What if your agents never stopped? 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. What do I mean by this? Let's break it down. When you're in the loop, it's you and the terminal. You're constantly applying your attention to write prompts. When you're near the loop, you're clicking, you're responding, you're giving advice, you're giving feedback. When you're out the loop, it's full cron. You have stepped away. You are not a requirement

2:43anymore. And this is the new mental model for understanding your agentic engineering skill by the results you can achieve. 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. So, why is in the loop such a problem? Let's talk about it. What's wrong with being in the loop? The problem with 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

3:14we're operating the right way. 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. 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. 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

3:47transition in between fully required butts and 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. We incrementally work toward the future we want to create where our systems can operate for us without us by first stepping away and then stepping in when we're required. 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. And we've been covering these on the channel week after week, but it

4:22looks like this. Instead of you being the trigger, you have a concrete event. Think webhook. Think cron. Think user action near 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? That's phase one and phase two agentic coding. That's in

4:44loop. That's yesterday's advantage. That's fully saturated. You want to switch to thinking about pro- active agents, proactive agent systems. The thing that they need kicks them off. 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

5:04the right information.

5:11Why 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

5:29it doesn't feel super disconnected. Let's walk through a real use case. The classic one we'll be 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

5:42check 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? 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

5:59after you check in. Very, very valuable. 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. Why do we need durable agents? Why can't we just throw classic pie, classic cloud code, classic code X at this problem? It's because we need to survive crashes, restarts, closed laptops. 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

6:30agent in their own sandbox. You want to give them their own CPU compute. And for the labs, also GPU compute. 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. 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. Again, there are a million ways

7:05to 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. And they're all exactly what you would 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. 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. The thing that really makes it a step change, a level up in your capacity, is

7:38that 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. Try to have a vibe coder vibe code this, they won't be able to. That's why GrokBot, that's why dots, that's why Claud's co-work and all their infrastructure exists is 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. I will say though this is technology I highly recommend you own

8:11because this is going to be a key part of what it means to engineer massively leveraged results in your favor. 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

8:36this. Hope that's clear.

8:42Once 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 and available 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. 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. This is not

9:13pie-in-the-sky information. This is what we cover on the channel week after week. Here is the 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. I've been talking with main 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. Agent work through, the AI developer workflow, it waits for your approval, and it is using

9:46Jev to judge every single row. 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. Okay, so that's a real example. What else? How else can you use proactive agents? 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

10:23stuff. [snorts] I like to hand wave, literally, [laughter] 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. We have done this. This UI is real, and I can pull it up right now. This is on a sandbox, and this was actually on my M-core 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

10:51it waits for me. 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 light speed. 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. 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

11:18time. You can see here, Loom cycle 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. 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

11:44that outperform the default by miles. 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. 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'm dropping in UI designs, I'm dropping in mock designs and then a primitive RSI loop is running. It's going to build against the mock and compare over and over and over until the UI matches the mock design I

12:18passed in. 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? 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. I can change the model, I can change the comparison agent, I can tweak the core

12:48four of the system. You can't build these systems without understanding the core four context model prompt tools. We'll talk about that in a second. 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. 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. You can see here I had Astra mirror this UI, it got a 86.1 match. I just drag and

13:21dropped an image in and it looped over this. 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 he'll climb toward this. Got a decent result here after iteration three, and then it failed to mirror even further. Okay, this was the Sonic 5.5, so not bad. 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

13:50recursively work toward an example. 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 senior plus level cracked engineer. This is where it all leads, these powerful systems. Let me make it super clear,

14:08once 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. Just like when you walk away from a session, at the end of the day, you close your clo- your code, you close your codex, you close your pie, it's done. The value you can get when

14:29you build a system like this is immense. There are other new, next level problems, you know, next generation, but all next 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 [music] by your device.

14:52Why do we build these durable agents? These agents persist on the device. Why do we need them? First off, they can be proactive. They can start working before you show up, before you wake up. They're multi-client. Again, browser, terminal, phone, anyone, anywhere can connect to it. This is really important for products. 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,

15:16much faster than they would otherwise. Long-running. Durable agents survive crashes, they survive restarts, and they have to. They have to have this property. 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. So, what are the essential

15:38skills 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. 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

15:55learned and expanded on your abilities. Most engineers, most content creators, most people talking about agents, they're just focused on this. This is 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. The one that's really worth a lot of attention and time when you move to the mid and advanced

16:22levels 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. It's 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. The advantage then becomes how can you specialize your results? How can you build a system that

17:00can do what others could not do? This is where software engineers have a huge advantage. 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 deep seek. Then of course, prompt engineering is how you

17:23instruct 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 to change the law for your agent. And then of course, the tools, the harness. This is a big one and these all make up the core four. You must learn

17:43these 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 cloud 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. 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. Agentic engineering is understanding these four. Your context,

18:17your 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

18:37you've been building up year after year. 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 cringey just throwing out phrases like multiply, exponential, parabolic, but it's true. It's factually true. And this is available to you because you can use these powerful new intelligent tools and then apply your knowledge in the context and the tokenomics and the prompt and

19:04the instructions and in your harnesses. The gap for engineers truly upskilling their agentic engineering has never been higher. As I always say, vibe coding is the floor, agentic engineering is the ceiling. So, what do I mean by this? Let's be super concrete. So, you select a specific model at the right cost performance speed trade-off. You then build a custom agent harness using

19:25whatever SDK you want. I recommend Pi. This enables you to start harness engineering specific tools to generate specific results for your product or application. You then realize that your agent could start firing off some negative commands. So, what do you do? You add a Jeff damage control. Maybe you get rid of the bash tool entirely because you realize how dangerous it is, and you just give your agent the exact results it wants. This is agentic engineering. 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

19:59engineering, 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. You build these systems so well, you don't have to look at what they're doing. That's the key. 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 The difference is massive. This is what it looks like. You are building the application layer. You

20:29are prompting your agent. We want to move to this new paradigm where you build a system that then builds the system on your behalf. That's the target. This is what it looks like. Build a system that builds the system. This is the guiding phrase I used 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. And so, here's the measure of your success now. You can use this as a concrete model, a concrete framework I'm recommending for engineers. This is something I'm

20:58obsessing over right now. Your measure of success is how many agents are working for you right now. Right now. In this very second. Now, obviously, I'm not talking about token maxing. Anyone can spin up a while loop and have an agent just do random 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, and ways that you might not have foreseen yet. 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

21:30advantage 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, and now all these three threads have turned into three threads where you have no idea what's going on. And you're just trusting the model more and more. That is not engineering. 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. You build the system that is built so well, you step

22:03away because you realize you are the bottleneck. 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. 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

22:30engineers using agents every single day. Link's going to be in the description for you. In [music] phase three, we focus purely on Out Loop agentic engineering. This is the next leap. [music] 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. Pre-sale starts soon, and throughout pre-sale, I'm going to be offering a huge discount on the product. And if you are 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,

23:02really well. What is this transition? Why is it 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. 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 agent to solve

23:23real problems. This agent keeps running. It's looking for triggers. You build systems that build systems. 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. And then, like and subscribe. [laughter] 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

23:48shock Mr. Beast O face thumbnail. [laughter and gasps] Right? Like this is our bread and butter on this channel. I've been here 4 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. 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. Again, like and

24:20subscribe. 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. 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

24:41have ever created and the most valuable. So, that's linked in the description. 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. Over the next month leading up to the the of the phase three product, I'm going to be sharing content directly from the phase three products 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. I want [music] to

25:09reward engineers that move fast and invest in themselves. So again, link in the description for that. It's going to be you or your competitors [music] that make this leap and I want it to be you. Whenever you sit down in the terminal, when you put your butt in the seat, I want you to really stop and [music] ask yourself, "Is there 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 [music] system. Comment down below if this all makes sense to you. Thanks for watching till the end. I'm going to be

25:36with you here till the end. You know where to find me every single Monday. Stay focused and keep building.