Loop engineering came for the enterprise. The hard part is the governed loop.

By Connie Yang, Co-founder and CEO, Nth AI. Published 2026-06-23.

In June 2026 the agent world stopped talking about prompts and started talking about loops. The insight is real, and it is the fourth layer of leverage after prompt, context, and harness engineering. But a loop that runs while you sleep on a laptop is not the same as a loop that an auditor can read on Monday. Here is what changes when loop engineering meets the enterprise.

In the second week of June 2026, a single sentence reorganized how a lot of people talk about working with AI. Stop prompting your agent. Design the loop that prompts it for you. The phrase that stuck was loop engineering, and it spread the way these things now spread. A post crossed millions of views in days, a Google engineer named Addy Osmani published an essay that gave the practice an anatomy, and the people building the most-used coding agents confirmed they had quietly stopped prompting by hand. Boris Cherny, who works on Claude Code at Anthropic, reduced it to four words. I do not prompt Claude anymore.

It is a good insight, and it is true. It is also, for the enterprise, the easy half of the story. Designing a loop that runs while you sleep is a laptop problem. Designing a loop that an auditor can read on Monday morning is the problem we actually get paid to solve. This is the enterprise translation.

From prompt to context to harness to loop

Loop engineering did not appear from nowhere. It is the fourth step in a progression, and each layer wraps the one before it rather than replacing it.

Prompt engineering is the craft of the single call. Word choice, examples, output format, the role you assign the model. It works for static, well-defined tasks and it breaks the moment the task needs information the model does not already hold.

Context engineering is the discipline of filling the window with the right material at the right time. Retrieval, memory, tool results, the state the model needs to behave reliably as a task unfolds. Anthropic's own writing on effective context engineering made the case that this, not prompting, was where the leverage had moved in 2025.

Harness engineering is the scaffolding around the model. The tools it can call, the sandbox it runs in, the validators that check its work, the connectors that let it touch real systems.

Loop engineering is the cycle that ties all of it together. The agent takes an action, reads feedback from its environment, uses that feedback to choose the next move, and continues until a defined stopping condition is met. The unit of work is no longer a prompt or even a conversation. It is the loop. You stop being the person in the chat box and become the person who builds the machine that runs the chat box.

Why it got hot when it did

The timing was not an accident of the discourse. The loop became the interesting layer because the underlying agents finally got good enough to stay inside one. By mid-2026 a coding agent could run autonomously long enough, and recover from its own mistakes well enough, that a single run might last an hour and touch dozens of files. When that is true, the highest-leverage thing you can do is not write a sharper sentence. It is design a loop that keeps the agent verified and on-goal for the whole hour.

That is the consumer and developer version of the story, and it is genuinely transformative for how software gets written. But notice the load-bearing word in it. Autonomy. The entire payoff is that the loop runs without you. In the enterprise, that is exactly the property you are not allowed to have for free.

The enterprise translation: most loops die in production

The most-cited number in enterprise AI conversations this year is that roughly 88 percent of agent pilots never reach production. When you ask teams where the pilots die, the answer is almost never the model and almost never the demo. The demo was great. The pilot died in the gap between a loop that works on a willing operator's screen and a loop the organization is willing to let run against real systems, real money, and real liability.

That gap is the loop. Specifically, it is everything a laptop loop gets to skip and an enterprise loop cannot.

A laptop loop terminates when the tests pass. An enterprise loop has to terminate in a way somebody will sign. A laptop loop's feedback signal is a linter or a type checker. An enterprise loop's feedback signal is often a decision with no test suite, no winner, and no answer key, where the only available verifier is a senior human who would have made the call themselves. A laptop loop's memory is a working directory. An enterprise loop's memory is a per-tenant record that legal, security, and finance all have a claim on.

So the practitioners who say the loop is the product are right. They just understated it for our context. In the enterprise, the loop is not only the product. The loop is the thing the product has to prove.

A consumer loop optimizes for autonomy. An enterprise loop optimizes for trust.

This is the whole difference in one line, and it changes every design decision downstream.

When autonomy is the goal, every human checkpoint is friction to be engineered out. The aspiration is the loop that runs while you sleep. When trust is the goal, the human checkpoint is not friction. It is the substrate. You do not get to run anything consequential while you sleep until you have accumulated enough evidence, in a form an auditor accepts, that the loop earns the autonomy. The checkpoint is where that evidence is made.

The industry has a term that captures the same idea from the runtime side. Moving from laptop loops to governed runtimes. The loop has to leave the willing operator's machine and run inside something that records what it did, enforces who approved it, and isolates one tenant's logic from another. That is not a downgrade of the loop engineering insight. It is the version of it that survives contact with a Fortune 500.

What a governed loop has that a laptop loop does not

Four primitives turn a laptop loop into one an enterprise can run. We have written about each of them on its own. Loop engineering is what makes clear they were always parts of a single machine.

A human-in-the-loop gate. Not a popup that asks are you sure. A real decision point where a consequential action stops, a named person approves, edits, or rejects the plan, and the delta is recorded. The gate is what makes the loop safe to run. It is also, and this is the part most teams miss, the richest evaluation signal in the entire system. Every edit and every rejection is a labeled disagreement between the agent and the operator, decomposed by decision type, updating in real time.

An evaluation loop. In domains where there is no right answer, you cannot evaluate on outcomes alone, because the outcome arrives in eighteen months confounded by everything else that happened. You evaluate the plan against a rubric, you track the disagreement rate at the gate, and you meter the small population of outcomes that are eventually observable. Three modes, three cadences. The eval loop is not a report you publish. It is the loop the whole platform lives inside.

An audit trail. Decision, evidence, model version, approver, timestamp, and the counterfactual you chose against. The same record the auditor reads backward next quarter is the record the rubric scorer reads forward next Friday. The accountability layer and the learning layer turn out to be the same layer, read in two directions.

Per-tenant memory. The loop's state is not a working directory. It is the enterprise's own definitions, baselines, and corrections, scoped to the enterprise and never pooled across tenants. A loop whose memory is shared across customers is a different product than the one any serious buyer will sign.

How we run loop engineering at Nth AI

Nexus, the platform we build, automates the context implementation loop that enterprise agents depend on. It turns fragmented data, metrics, policies, and business logic into governed context through four stages: discover, define, build, compound.

In discover, the platform reads the fragmented systems that already hold the truth and proposes the semantic layer. In define, a human approves the definitions, KPIs, mappings, policies, and business rules. That approval is a gate, and the gate writes to the record. In build, Nexus produces the models, ontologies, and controls agents need, and every consequential step routes back through a gate before it touches a system that matters. In compound, every correction, approved definition, disagreement at the gate, and eval result becomes governed context for the next run.

That last stage is where loop engineering stops being a technique and becomes a moat. The output of one loop is the starting state of the next. A correction a human approved in March is context the agent already has in June. The next use case in the same enterprise does not start from zero. It starts from an approved, governed corpus of how that enterprise actually works. The loop that implements the context and the loop that improves its reliability are the same loop, just read on a longer timescale.

This is the practical answer to the question every buyer asks. How do I know the agent is getting better. Because the loop that makes it better is the same loop that already made it accountable, and you have been watching that loop run, with your name on the approvals, the whole time.

The part the discourse got exactly right

For all the translation it needs, the core claim of loop engineering is correct, and it is the right thing to organize around. The leverage has moved from the prompt to the loop. The person who designs the loop beats the person who writes the perfect instruction, in the same way the person who builds the factory beats the person who hand-makes the part.

The enterprise just adds one clause to the claim, and it is the clause we have spent our careers inside. You do not get to design a loop that runs while you sleep unless someone can audit what it did when it wakes you up. Build that loop, and the autonomy is earned rather than asserted. Skip it, and you have a very impressive demo and an 88 percent chance of joining the pilots that never shipped.

The loop is the product. In the enterprise, the governed loop is the only product that ships.