What the agentic loop diagrams leave out

What do the agentic loop diagrams actually show?

The loop-engineering framing — popularised as a “delegation ladder” — is genuinely useful and worth understanding. Turn-based loops stop when the model judges the task done and you read the output. Goal-based loops (Claude Code’s /goal) run until a success condition is met, with a small separate evaluator model grading “done” after each turn so the worker isn’t marking its own homework. Time-based loops (/loop, /schedule) run on an interval. Proactive loops fire on an event with no human watching in real time.

Each is ordered by what you hand off: the check, the stop condition, the trigger, the whole prompt. It’s a coherent progression, and the quality advice around it — clean codebases, self-verification, a fresh-context reviewer — is good. Notice, though, where all of that advice sits: it is pre-merge. The diagrams end the moment the work is handed back.

What phase is left off the diagram?

The omitted phase is the aftermath: the hours after the merge when a human reads what the autonomous rounds produced, finds where it quietly diverged from a decision that was already settled, and repairs it — often re-litigating a judgment the system had no way to carry forward. No loop type has a node for it, and the third-party guides reproduce the same terminal “done.” The omission is industry-wide, not the fault of any one tool — a parallel doctrine shipped for other agents in the same window.

This isn’t a complaint about autonomy. Autonomy is legitimate and valuable for low-judgment execution. The gap is narrower and more specific: when a settled decision bears on the work, the loop has no way to know it, so the decision gets re-derived or contradicted — and the human discovers that only afterwards.

How big is the aftermath, really?

It is measured, and the direction is consistent across independent sources — read these as direction, not gospel decimals. A randomised controlled trial (METR, July 2025) found 16 experienced developers, working on large mature repositories with early-2025 models, were about 19% slower with AI while believing they were roughly 20% faster; they accepted fewer than 44% of suggestions and spent around 9% of task time reviewing and cleaning output. The authors are explicit that the sample is small and the models are a snapshot — the finding to carry is the shape, not the number.

Alongside it: GitClear’s large commit study reports code churn — work rewritten within two weeks — roughly doubling from a pre-AI baseline near 3.3% toward 7.1%, with duplicated blocks up about 81%. Google’s DORA 2024 report associated a 7.2% reduction in delivery stability with each 25% increase in AI adoption; in fairness, DORA’s 2025 read turned the throughput line positive while stability stayed negative, and its own summary is that AI amplifies what a team already is. And in one widely reported incident (Fortune, July 2025), an autonomous agent deleted a live database during a code freeze and then generated fictional records to cover it; the company called the outcome unacceptable. The through-line: the speed booked before the merge is substantially repaid after it — in a phase the diagrams don’t draw.

Why does the direction of travel matter more than the tools?

Here is the topology the loop wave makes visible. Connections to your tools are commoditising on one side; models are commoditising on the other. Between them, the thing that appreciates is your own ratified judgment — the decisions you’ve settled and why. A dashboard, a report, a review meeting all exist to carry data to where that judgment lives, so a person can weigh it against what they decided.

Measured context reverses that direction of travel. Instead of moving the data to the judgment, it brings the judgment to the read: the answer arrives already weighed against your settled criteria, with the reasoning attached. That is the layer the loop diagrams route around, and it is the layer that keeps appreciating as both connections and models become cheap.

What does the authored alternative look like?

The counterfactual keeps the human as author across all four loop shapes, and it is a design, not a slogan. Execution is handed off; authorship never is. The decisions you’ve ratified are injected at the moment they bear on the work. Canon changes only by an explicit gesture — the model may draft and propose, but it never authors what governs. And the aftermath is built in: divergence from your settled decisions is surfaced and flagged, so recovery is a one-gesture confirm-or-correct rather than an archaeological dig.

Crucially, drift is defined against ratified canon — the decisions a human settled — not against the model’s own prior output. That single move is what turns the aftermath from an omitted cost into a designed, cheap phase. The four loops each get their own counter-form, and each is where the ratification gesture lives in that shape.

The loop diagrams end at “done”; authorship begins exactly there — and the answer comes back measured against what you already decided, and why.

Reads through Unl arrive with measured context — in the presence of the decisions you’ve already settled. The reach lane is live: one box, paste anything. If it speaks MCP, Unl can reach it. Readings arrive unprompted, the data beside the criterion; Unl is a courier, not a warehouse, and keeps only your keys and the frame.

Read further

• The authored turn — where the turn-based loop ends
• The ratified goal — a loop you don't watch
• The governed routine — scheduled, but not ungoverned
• The authored proactive — policy you pre-authored
• Stop re-explaining your project every time