Leaving the Loop: In → Near → Out for Agentic Engineers

0:00The opening claim is deliberately provocative: "AI agents make fewer mistakes than you or I on our best days as engineers." Give Opus 5.5 a hard task and read the trace — "it looks like an alien engineer running the most obscene bash commands and tool-call combinations." Opus and Astra do this back-to-back-to-back. So the smart question: if the agent is a better programmer inside the loop, why are you still sitting in it?

In → near → out

2:07The mental model, in one line each: in the loop = you and the terminal, writing prompts (prompt, click, cron); near the loop = you're clicking, approving, giving feedback; out the loop = full cron, you've stepped away, "you are not a requirement anymore." The guiding question for everything: "What can run without you next?" Experience doesn't auto-unlock this — "your experience pays off only if you change how you operate."

You are the bottleneck

3:02The problem with being in the loop: you and I are now the limitation. The hard truth: "80% or more of all the work we're doing right now can run without you, with the right system in place." The progression is the point — you're constantly "building the system that builds the system." Jumping straight from in-loop to out-loop is hard, so you move near the loop first: step away, then step in only when required. The difference between the two operating modes is proactive vs reactive.

Proactive agents

4:11Instead of you being the trigger, the trigger is a concrete event — a webhook, cron, a user action, or Jev classifying an event from your log stream. "There are a million ways to kick off your agent. Why are you still the main one?" The reframe: the thing that kicks off the agent "isn't you. It's information — the right information." The agentic engineer's job becomes: get the right agent the right information. The classic flow: event → Jev triage → patch prepared → agent presents it → you check in, decide, walk away — the AI developer workflow (detect, triage, patch, ask, apply, verify) keeps running after you leave.

The core elements

6:01Three things make a near-loop system. Durable agents — because you need to survive crashes, restarts, and closed laptops. A sandbox — give the agent its own CPU (and GPU for the labs), always-on, isolated, autonomous, "scaling your agents into their own environments where they have all the tools you have — and the most important tool is a full computer." A clear API layer — so a variety of triggers (cron, log events, tickets, UIs, image drops, other CLI agents) can activate the system. Durable agent + trigger + sandbox = a proactive agent that "works for you, then waits." This is why Grokbot, dots, and Claude Cowork exist — "commoditizing this for the average user" — and why he argues you should own the technology yourself.

Real examples

8:42Two live systems. Incident response: an event hits the log stream, Jev classifies it, the on-call agent runs the workflow (detect, investigate, root-cause, fix, prep review) — and you're just the reviewer who clicks deploy. 12:00Deep Jev UI replicator: drop in a UI mock or screenshot, and an agent loops build → screenshot → compare against the mock, hill-climbing until it passes a similarity threshold (two or more agents, optionally) — one run reached 86.1% on an Astra-mirrored UI. The durable news agent (last week's video) is a third: Jev filters hype and surfaces actionable signal, running 24/7 and improving via upvotes. The through-line: the best engineers are moving "from individual engineering agents to product agents focused on a specific use case that outperform the default by miles."

The core four

15:38Everything reduces to context, model, prompt, tools — and the one worth the most attention at mid/advanced levels is harness engineering, "wrapping powerful intelligence in a system that can outperform the baseline." That's why he keeps pushing Pi and Pi Durable: there you can expand the agent's actions and customize results. 19:17The concrete example: select the right model at the right cost/performance/speed trade-off (understand tokenomics — "these subsidized subscriptions won't last forever"), build a custom harness (he recommends Pi), then notice your agent might "fire off negative commands" — so you add a Jev damage-control gate, or remove the bash tool entirely and hand the agent only the exact results it needs. That's agentic engineering applied to security, model selection, and harness design. The frame: "vibe coding is the floor, agentic engineering is the ceiling" — vibe coding is not knowing what your system does; agentic engineering is knowing it so well you don't have to look.

The measure of success

20:53The concrete metric he's obsessing over: how many agents are working for you right now — in this very second. Not token-maxing (anyone can spin a while-loop); he means useful work you understand, products built with agents running without you. The trap he names: split your attention across three terminals and "you're just trusting the model more and more — that is not engineering. Engineering is building systems you reliably know will do what you're looking for." It's the move from low-leverage to high-leverage agentic engineering: build the system so well you step away.

Phase three

22:08The pitch that frames the whole thing: augment → automate → deprecate, the three-stage cycle of every technological revolution — and "phase three is the deprecation phase," which he calls zero-touch engineering (ZTE). The flow he leaves you with: in-loop you prompt, near-loop you approve, out-loop you observe. The rest of the video closes with a pre-sale for his Phase 3 course/product (advanced engineers only, "if you don't fall into that bucket, this product is not for you") — flagged here, not covered.

Claims checked

Sources & further reading