Summaries > AI > Engineers > ELITE Agentic Engineers Are LEAVING THE LOOP... Hereâ€™s why...

Elite Agentic Engineers Are Leaving The Loop... Hereâ€™S Why

https://www.youtube.com/watch?v=52JX83rGPLc

TLDR Agentic engineering is about moving from constantly supervising AI to building durable, reliable agents that respond to triggers, work in sandboxes, and handle useful tasks with minimal oversight. Engineers should master context, models, prompts, tools, and memory to create systems that build and improve software on their behalf, progressing from prompting agents to approving their work and eventually stepping back to observe.

Key Insights

Start by identifying work that does not need constant human attention

Review recurring engineering tasks and ask, “What can run without you next?” Look for work with clear inputs and success criteria, such as sorting log events, summarizing news, or reproducing a known interface. Start with a task where an agent can produce a useful result without making an irreversible decision. This gives you a practical first step toward reducing manual supervision.

Move from prompting agents to reviewing their decisions

Use a gradual progression: in the loop, you prompt and supervise; near the loop, an agent starts work and asks for targeted decisions; out of the loop, you mainly observe a trusted system. Near-loop workflows are a useful transition because people can review important results without triggering every step. For example, an agent can investigate an incident and propose a patch, then wait for an engineer to approve deployment. Keep human review at consequential decision points until the workflow is reliable.

Connect agents to clear triggers and practical tools

Give agents defined ways to begin work, such as scheduled jobs, log events, tickets, user actions, or command-line requests. Connect those triggers through a clear API layer so the agent receives the right context and can return its results consistently. Provide only the tools needed for the task, rather than unrestricted access; for instance, remove a dangerous shell capability if the agent does not need it. Narrow permissions and explicit workflows make agent behavior easier to control and verify.

Build agents that can persist and recover

A useful autonomous workflow should not depend on your laptop staying open or on a single uninterrupted session. Run agents in isolated sandboxes with their own compute and the tools required to complete their work. Add durable memory so they can retain relevant context, recover after crashes or restarts, and continue waiting for human input when needed. Test recovery behavior before relying on an agent for important operational tasks.

Engineer the agent system around the task

Reliable agents require more than a model and a prompt: they also need suitable context, tools, safeguards, and a well-designed execution harness. Select a model and token budget that fit the task, provide relevant information, and define what a successful result looks like. Use domain expertise to customize the workflow rather than relying on a default agent setup. Measure success by useful work completed reliably, not by the number of agents running.

Validate results before expanding autonomy

Start by having an agent produce work that a person can inspect, such as an incident analysis, a proposed code change, or a screenshot comparison against a design. Check its output against explicit criteria and use feedback to improve the workflow. For example, a UI-replication agent can iterate toward a measured visual-similarity target, while a human verifies whether the result is acceptable. Expand the agent’s responsibility only after repeated testing shows that it handles the task consistently.

Scale from automation toward zero-touch engineering

Once a workflow is dependable, consider the progression from augmenting human work to automating it and eventually deprecating unnecessary manual steps. Make agents accessible through appropriate clients, such as a browser, terminal, or phone, and design for collaboration across engineering, product, design, and support. Keep monitoring and escalation paths in place for failures or decisions outside the agent’s authority. The long-term goal is to build systems that perform useful work independently while people focus on building, improving, and overseeing those systems.

Questions & Answers

What is the progression from in-the-loop to out-of-the-loop engineering?

In the loop, you constantly prompt and supervise agents; near the loop, agents do work proactively and pause for your decisions or approval; out of the loop, trustworthy systems work autonomously while you observe.

What is a durable agent, and why is it useful?

A durable agent persists through crashes and restarts, retains context, and can continue working without constant supervision. It can investigate problems, prepare solutions, and wait for a person to review or approve them.

What components are needed to build proactive agent systems?

A durable agent, an isolated sandbox with the tools and compute it needs, and an API layer connecting it to triggers such as scheduled jobs, log events, tickets, user actions, or CLI workflows.

What are examples of useful durable-agent workflows?

An incident-response agent can detect an issue, investigate its cause, prepare a fix, and wait for an engineer’s approval. Other examples include a news agent that filters information and a UI-replication agent that iteratively compares screenshots with a design.

What core skills are needed for agentic engineering?

The core skills are context engineering, selecting models and managing token costs, prompt engineering, and harness engineering—customizing tools and safeguards so agents reliably perform specialized work.

How should success with agents be measured?

Measure success by how many agents are performing useful work for you at a given time, rather than by how many agents you can create.

What is the broader goal of agentic engineering?

Build reliable systems that do useful work with minimal oversight, ultimately creating systems that can build applications or other systems on your behalf.

Summary of Timestamps

AI agents can now handle difficult engineering work, but getting real value from them requires changing how we work. The goal is to progress from being “in the loop,” constantly prompting and supervising, to “near the loop,” reviewing key decisions, and eventually “out of the loop,” where dependable systems work autonomously. A useful guiding question is: “What can run without you next?”

Near-loop systems offer a practical transition. An agent can proactively respond to an event—such as a log entry—by classifying and investigating it, preparing a proposed fix, and presenting that work for human review. After approval, an AI workflow can apply and verify the change. This shifts people from triggering every step to making focused decisions.

Proactive workflows depend on three building blocks: durable agents that retain their work through crashes and restarts, isolated sandboxes with their own computing resources and tools, and an API layer that connects agents to triggers such as scheduled jobs, logs, tickets, user actions, and command-line workflows. Together, these let an agent act independently and pause when human input is needed.

Durable agents can preserve context, ask questions, and complete tasks without continuous supervision. For instance, an incident-response agent could detect an issue, investigate its cause, prepare a fix, and wait for an engineer to review and deploy it. The speaker emphasizes that these systems are already being built and introduced in practice.

The speaker demonstrates a news agent that has run continuously for a week and a half, filtering for useful, less-biased information and improving from user feedback. A second example is a UI-replication agent that builds a design, compares screenshots, and revises its work toward a target; one cloud-based run reached an 86.1% visual match. Both examples show agents producing useful results while the user steps away.

The broader vision is to move from in-loop to near-loop and ultimately out-loop engineering. Agents should run in sandboxes rather than depend on a personal device, be accessible through clients such as a browser, terminal, or phone, and support collaboration across engineering, product, design, and support. This requires understanding context, models, prompts, tools, and reliable memory.

Agentic engineering means building durable systems that do useful work without constant oversight. Its core skills include context engineering, choosing models with token costs in mind, prompt engineering, and harness engineering—the customization of tools and safeguards. Engineers can multiply their domain expertise by applying these skills; simply using a default agent or vibe-coding is not a lasting advantage.

A strong agent system should have clear, dependable behavior and only the capabilities it needs. For example, removing a risky bash tool and providing a narrower set of tools can make an agent safer and more specialized. Success is better measured by how many agents are doing useful work at a given moment than by how many agents can be launched.

The next stage is described as “Phase Three,” following the cycle of augment, automate, and deprecate, with a focus on zero-touch engineering. The speaker is developing this advanced product for engineers who already use agents regularly and says it is intended for experienced users. Pre-sale is expected to begin soon, with a discount that also applies to Phase Two Tactical Agentic Coding members.

The central progression is simple: in the loop, you prompt; near the loop, you approve; out of the loop, you observe. Engineers can move toward that future by mastering agent fundamentals, using durable agents to solve real problems and respond to triggers, and building systems that build systems. The speaker encourages viewers to ask whether they truly need to stay involved in a task—apart from building the system itself—and promises Phase Three previews, related videos, and ongoing updates.