Give the AI the Decision, Not the Control: Why Free-Form Agent Loops Are Often Too Open

Autonomy is a dial, not a switch. Why most production AI systems get better when the model only sits at clearly bounded decision points - instead of steering an open agent loop.

·36 min read·Made with AI

Autonomy is a dial, not a switch - and most production systems don’t turn it all the way up.

At the end of the last post, I deliberately left one lever untouched: “Instead of protecting the agent from delete_account in the hundredth test, we could simply not hand it the tool at that point in the first place. […] But that’s another post.” This is that post.

As a reminder, here’s the case: a self-service agent for account settings. A user writes “Please stop sending marketing emails to my address”, and the agent calls delete_account instead of unsubscribe_marketing. The tool call runs through cleanly, success: true, the account is gone. Three days later, the user is missing their billing history, which disappeared along with the account. A routing failure on a destructive tool, triggered by a completely harmless phrasing.

From Incident to Regression Test: How Production Failures Make Their Way into Your Eval Set
An eval suite that doesn't grow with your incidents shrinks relative to reality. What the postmortem-to-eval loop looks like in practice, from the trace ID to the required field in the postmortem template.
rubeen.dev/en/blog/incident-zu-regressionstest
→

The answer throughout this series so far has been: one more eval that covers this case. One more confirmation gate in front of the irreversible action. And a post-processor that catches the damage afterwards. All correct. And all after the fact - protective layers we wrap around an architecture that makes the failure possible in the first place.

But one question comes before all of that: why did the agent have delete_account within reach at that moment, free to pick between tools? “Change marketing preferences” and “delete account” aren’t the same operation with a different argument. If the two are structurally separate paths, the destructive action simply isn’t on the model’s menu at that point. The failure doesn’t get caught. It never happens.

Behind this is an architecture decision: how much room do we give the model to determine its own flow? The default assumption is often “as much as possible”. In most production systems, that’s the wrong default.

The dial: who owns the control flow?

Let’s picture the dial concretely. On the far left sits a system whose flow is written entirely in code and that only consults the model at specific points. On the far right sits a system that decides for itself which step to take next, which tool to call, and when it’s done. Everything else lies in between - and most of what actually runs in production lives right there in the middle.

The axis behind the dial is a single question: who owns the control flow? In a workflow, the code owns it. Anthropic defines it like this in “Building Effective Agents”: “Workflows are systems where LLMs and tools are orchestrated through predefined code paths.” In an agent, the model owns it: “Agents … are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.” What differs is who’s in charge of the order of steps. The model is the same in both cases.

On the left of the dial is the augmented LLM, which Anthropic calls the basic building block of agentic systems: a model with retrieval, tools, and memory, but without a flow of its own. A bit further right comes prompt chaining, where code breaks a task into fixed steps and passes each output to the next call. Then routing, which classifies an input and sends it to a specialized next step. After that, parallelization, which splits a task into fixed pieces or runs it several times, and orchestrator-workers, where a central model distributes subtasks only at runtime and merges the results. And on the far right, the free-form agent loop that finds its own way.

Here’s what the dial looks like:

The autonomy spectrum from workflow to agentSix architecture levels from left to right, ordered by who owns the control flow. On the left, the code owns the control flow (maximum control): augmented LLM, prompt chaining, routing, parallelization, orchestrator-workers. On the far right, the model owns the control flow (maximum flexibility): the free-form agent loop. With every step to the right, the code hands more flow control to the model.AugmentedLLM1 call + toolsPromptChainingSteps + gatesRoutingClassifyParallelizationSectioning · votingOrchestrator-WorkersDynamic subtasksFree-formagent loopModel steersCode owns the control flowmaximum controlModel owns the control flowmaximum flexibilityWorkflows: predefined code paths · Agent: the model steers its own flow and tool use
Autonomy as a dial: from left to right, the code hands more flow control to the model. On the left, the augmented LLM as the basic building block, then four of Anthropic’s five workflow patterns - in all of them the code owns the control flow, and the model only sits at individual decision points. Only on the far right, with the free-form agent loop, does the model steer the process itself.

The concept that makes the dial usable at all is the decision point. That’s a spot where the model’s judgment adds real value: classification, extraction, handling ambiguity, synthesis from multiple sources. No if reliably captures things like that. Flow control, on the other hand, is something code does better: what comes after what, when to stop, which branch runs. A deterministic path handles that more precisely, more cheaply, and more traceably than any model. Setting the dial right means giving the model the decision points and taking the flow control away from it.

To see what that means in practice, let’s put one task at three points on the dial. Say, “answer a support ticket”.

On the far left, as an augmented LLM call: one prompt, ticket in, answer out, maybe with access to an FAQ search. Fast, cheap, predictable. What’s missing is anything that goes beyond one step - the model can’t first look up the order status and then decide what to do next based on the result.

One step further right, as a routing workflow: a first call classifies the ticket as a billing question, a technical problem, or a complaint, and the code sends it to the matching handler. Each handler has its own narrowly scoped tools. You gain structure and keep control over what is allowed to happen in which case. You lose flexibility for cases that don’t fit into any of your boxes.

On the far right, as a free-form agent: the model gets the ticket, a set of tools, and the goal “solve this”. It looks things up, asks follow-up questions, calls APIs, and decides for itself when it’s done. The most powerful variant - and the one where you know the least about what actually happened between input and answer.

Anthropic draws a sober conclusion from this: “When building applications with LLMs, we recommend finding the simplest solution possible, and only increasing complexity when needed. This might mean not building agentic systems at all.” The message: set the dial deliberately instead of pushing it all the way right by default. The same principle is behind least agency, which I described in the human-in-the-loop post: only as much autonomy as the task actually requires.

A
Building effective AI agents
Practical guidance from Anthropic on building reliable AI agents, from simple composable patterns to fully autonomous systems.
anthropic.com
→
Approval Isn't a UX Bug: Why Agent Systems Need to Know When to Ask
Human in the loop isn't a weakness, it's security architecture. Why pause/resume for critical agent actions may be the most important feature of all.
rubeen.dev/en/blog/human-in-the-loop
→

That leaves the question of why “far right” comes at a price at all. After all, the free-form loop can do everything the variants on the left can, plus what they can’t. The answer is that every additional step in the loop costs something - and that these costs don’t grow linearly.

Why the open loop breaks in production

Costs that don’t grow linearly: that was the short answer at the end of the last section. The forces behind it are easy enough to name: a free-form loop breaks in production from four directions, and each one gets worse the further the dial moves to the right.

Compounding error. Every step in the loop is its own roll of the dice. In the observability post, I did the math: 10 agent steps at 99% accuracy each end up at 90% overall accuracy. Sounds like nitpicking, but it’s multiplication - 0.99 to the power of ten. A workflow with three fixed steps and one model call in between has a single one of these rolls. A free-form loop that finds its way over fifteen iterations has fifteen. Structure shortens the loop, and a shorter loop fails more slowly.

Observability for AI features: which spans, events and IDs you actually need
Without traces, model and prompt versions, tool spans and cost metrics, every incident stays guesswork. A guide for teams running AI features in production.
rubeen.dev/en/blog/observability-ai-features
→

Non-determinism and rollout. More free branches mean more paths no test has ever seen. In the rollout post, that was the stochastic regression that hits maybe 3% of cases. The p99 latency stays green. The error rate stays green. Except that in those 3%, the model now takes a turn that wasn’t there before, and nobody notices until a customer complains. A structured flow has a finite number of named paths. I can shadow-test them, compare them against the baseline, canary them one by one. With a free-form loop, all that’s left is prayer.

Release Discipline for AI Features: Canary, Shadow Runs and Automatic Rollback
Green eval in the PR, red numbers in production two weeks later - without a new deploy. Why AI features need their own gates between merge and 100% traffic.
rubeen.dev/en/blog/ai-rollout-canary-shadow
→

Cost and latency. For its multi-agent research system, Anthropic disclosed that agents typically use about four times as many tokens as a chat interaction, and multi-agent systems roughly fifteen times as many. The reason is mundane: the loop also “thinks” in places where an if would have done the job. Anthropic itself frames the tradeoff plainly - agentic systems trade latency and cost for better task performance, and you should weigh when that trade pays off. For open-ended research, it can. For “unsubscribe from marketing emails”, you’re paying reasoning tokens for a decision a routing table makes in a millisecond.

Auditability. A known flow is traceable: for request X, path A ran, here are the logs. A free-form loop potentially takes a different path for every request, which turns the question “why did the system do that?” into a forensic exercise. For high-risk systems, the EU AI Act makes this an obligation. Article 14 requires that humans can intervene, override, and stop the system; Article 12 requires complete record-keeping. In a structured flow, you get both almost for free, because the intervention points and the logs sit at the path boundaries that are already in the code anyway. In a free-form loop, you have to surgically graft them in after the fact.

All four points have one thing in common: they get monotonically worse with the width of the loop. There’s no threshold beyond which more freedom suddenly becomes free.

A publicly reported case shows what this looks like at scale. In July 2025, a Replit agent deleted SaaStr’s production database during an active code freeze, despite explicit instructions not to change anything. According to the AI Incident Database, the data of around 1,200 companies was affected. What’s interesting isn’t so much that the model was “wrong”, but that a destructive database command was within the agent’s reachable choices at all and was executed autonomously, without approval. According to the screenshots Jason Lemkin posted, the agent afterwards described its own actions as a “catastrophic error in judgment” - there is no official postmortem with that wording.

Replit’s reaction afterwards is revealing. CEO Amjad Masad announced automatic separation of development and production databases including staging, a planning or chat-only mode, and one-click restore. These are the structures that fence in the loop after the fact - the same ones that could have been put in place beforehand.

None of this argues against agents. It just shows that the four breaking points follow from one architecture decision and can be avoided with a different one: by letting the code own the flow and having the model decide only where its judgment counts. What that looks like concretely, and how a destructive command never ends up next to a harmless one in the same choice space, is what we’ll look at next.

AI at decision points - the pattern

The four breaking points from the last section share a common root: the model owns the control flow. It doesn’t just decide what is right from a business perspective, but also in which order tools run, when the loop ends, and whether now is the time for a destructive call. The alternative flips this one responsibility, and it’s older than most agent frameworks.

HumanLayer’s 12-Factor Agents call this Factor 8: Own Your Control Flow. The starting point in the repo is an uncomfortable observation: most products that call themselves “AI agents” aren’t all that agentic - “mostly deterministic code, with LLM steps sprinkled in at just the right points to make the experience truly magical”. That’s the blueprint. Deterministic code as the scaffold, LLM steps sprinkled in at the points where judgment counts. The LLM outputs structured data, a decision or a classification. Your code takes that data and executes. Every step becomes a place where you can pause, validate, or log.

If you’ve read the tools post, you know half the idea. There it was about “intent vs. execution” at the tool level: the model expresses an intent, a gate checks the individual call before it’s executed. Here we move the same separation one floor up, to the flow level. It’s not the individual call that gets checked, but the order in which anything happens at all.

Tools Aren't Prompts: Why Agent Actions Need Idempotency, Auth, and Audit
A tool call can move money and change accounts. Why idempotency, auth, and audit in agent architectures aren't a nice extra but a hard requirement.
rubeen.dev/en/blog/tools-sind-keine-prompts
→

The model decides what should happen. The code decides whether and how it happens.

Here’s what that looks like in the refund-agent. Instead of letting the model pick from all the tools in a free-form loop, it makes just one decision, the route, and the rest is a deterministic switch:

import { generateObject } from "ai";
import { z } from "zod";

// 1. The model decides ONLY the route - a single decision point.
const RouteDecision = z.object({
  route: z.enum(["refund", "lookup", "account", "clarify"]),
  reason: z.string(),
});

const { object: decision } = await generateObject({
  model,
  schema: RouteDecision,
  prompt: buildRoutingPrompt(userMessage),
});

// 2. The code owns the control flow - a deterministic switch executes.
switch (decision.route) {
  case "refund":  return handleRefund(ctx);   // narrowly tool-isolated handler
  case "lookup":  return handleLookup(ctx);    // read-only tools only
  case "account": return handleAccount(ctx);   // separates reversible from destructive
  case "clarify": return askClarifyingQuestion(decision.reason);
}

// The account handler separates the harmless route from the irreversible one.
function handleAccount(ctx: Ctx) {
  const intent = classifyAccountIntent(ctx); // another narrow decision point
  if (intent.kind === "preferences") {
    return updatePreferences(ctx);           // reversible, no gate needed
  }
  // destructive: its own path with an approval gate - never in the free choice space
  return requireConfirmation(intent, ctx);   // gate from the human-in-the-loop post
}

Two things happen here. The model classifies the request into one of four routes, nothing more. It doesn’t pick tools and doesn’t plan an order. And the switch owns the control flow: every route leads into a narrowly tailored handler, lookup only gets read-only tools, refund a tool-isolated path.

The interesting part is in handleAccount. Remember the self-service agent that wrongly called delete_account on “unsubscribe from marketing emails”? In a free-form loop, unsubscribe_marketing and delete_account sit in the same choice space, two entries in the same tool list, and only the model’s judgment separates the reversible from the irreversible. In the structured flow, that shared space doesn’t exist. The handler first classifies whether this is about harmless preferences or a destructive action. Harmless stuff goes straight through. The irreversible gets its own path with an approval gate, the same gate from the human-in-the-loop post. The delete_account bug structurally can’t happen anymore - not because the model is smarter, but because the irreversible call was never up for free choice.

A nice side effect: a flow like this is also easier to evaluate. In the evals post, one of the grader families was routeMatch and requiredToolsCalled - did the model pick the right route, were the expected tools called? With a free-form loop, every request takes a different path, which is hard to pin down. A flow with four named routes has four testable cases.

This routing is just one of several building blocks. In “Building Effective Agents”, Anthropic described five such patterns - a toolbox between pure workflow and free-form agent.

Anthropic's five workflow patterns at a glance

Prompt chaining - breaks a task into a sequence of steps; each LLM call processes the output of the previous one.

Routing - classifies an input and directs it to a specialized follow-up task (the pattern in the code above).

Parallelization - in two variants: sectioning splits a task into independent subtasks that run in parallel; voting runs the same task several times to get diverse results.

Orchestrator-workers - a central LLM breaks down tasks dynamically, delegates them to worker LLMs, and synthesizes their results. Unlike parallelization, the subtasks aren’t fixed in advance but determined by the orchestrator depending on the input.

Evaluator-optimizer - one LLM call generates a response, a second one evaluates it and gives feedback, in a loop.

These building blocks can be mixed: a workflow with embedded AI steps, an agent that sits entirely behind a gate, or a workflow that starts an agent as a worker when needed. If you own the control flow, you build the control structure that fits the use case. How deep that goes depends on the tool.

Frameworks for control flow ownership

LangGraph - models paths explicitly as nodes and edges; interrupt() pauses the graph for human-in-the-loop and resumes it later. (Graph API, Interrupts)

Temporal - durable execution: if the process crashes, the state is restored automatically and processing continues where it left off. (Temporal & AI)

Lightweight - for simple routing flows, structured output plus your own switch is enough. No framework needed; the code above is all there is.

G
12-factor-agents/content/factor-08-own-your-control-flow.md at main · humanlayer/12-factor-agents
What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers? - humanlayer/12-factor-agents
github.com
→

The spectrum ranges from a lightweight switch to a durable workflow engine. What’s still open is the dosage: an FAQ bot doesn’t need a Temporal cluster, and a codebase investigation won’t get far with four fixed routes. So when do I need how much of this?

How much loop can this task handle?

The pattern from the last section answers the how: the model decides what should happen, the code decides whether and how. It doesn’t answer the how much. Where a concrete task lands on the dial is an architecture decision, and I base it on a few axes. Each one pushes the dial left toward workflow or right toward loop.

Predictability of subtasks

Do I know the steps in advance, or do they only emerge at runtime?

With a refund, I know the flow in advance: look up the order, check eligibility, refund, confirm. Finite, known steps belong in a workflow, in code that owns the order. If the flow can’t be planned in advance because each intermediate step determines the next (research where every finding opens the next search), that points to orchestrator-workers or a free-form loop.

Blast radius and reversibility

What happens in the worst case, and can I undo it?

Read-only and harmless? Then the loop isn’t critical. A model that gets lost during a search costs tokens, not money or data. As soon as an action is irreversible, moves money, or touches customer data, it belongs behind structure and a gate. That’s the delete_account path from the intro: never in the free choice space, always its own path with confirmation.

Auditability and regulation

Will I have to prove later why the system acted the way it did?

For an internal, low-risk tool, more freedom is fine. As soon as the application falls under the EU AI Act as a high-risk system, it becomes a hard requirement - the override and logging obligations from section 2 read here as a decision axis: a flow with known paths meets them almost in passing; a free-form loop turns the later proof into archaeology.

Cost and latency

What does it cost to let the model think where an if would have done the job?

A free-form loop burns compute even in places where a case distinction in code would do the job more reliably and more cheaply. With tight latency or cost budgets, the workflow wins. For rare, complex tasks where quality matters more than cost, the loop can pay off.

The four axes rarely pull in the same direction, but for common tasks they can be condensed:

Task Dial setting Why
FAQ answer Augmented LLM, single call One decision point, harmless, read-only
Order status Routing workflow Known flow, read-only tools only
Refund processing Workflow + approval gate Moves money, irreversible, subject to audit
Invoice extraction Workflow with AI step Finite steps, model only for parsing
Open-ended codebase investigation Free-form loop / orchestrator-workers Flow can’t be planned, read-only, quality counts

The broader trend points the same way. Gartner predicts that “40% of Enterprise Apps Will Feature Task-Specific AI Agents by 2026, Up from Less Than 5% in 2025” - task-specific means narrowly tailored, with a clear mandate.

Still, the last row of the table is the honest point: there are tasks where structure is a cage. Open-ended research and creative synthesis depend on the system following directions nobody could know in advance. Anthropic reports that a multi-agent system with a Claude Opus 4 lead and Claude Sonnet 4 subagents beat a single agent by 90.2% on its internal research eval, especially on breadth-first queries that pursue several independent directions at once. Not a public benchmark, but a clear signal: where the subtasks only emerge during the search, the open loop is the right choice.

The dial isn’t a one-time setting either. Whatever goes to production should start narrow and structured and only open up in a controlled way based on measured performance, not the other way around. In the evals post, the advice was “don’t define the paths too strictly - otherwise it’s a sign that a deterministic system might be the better fit after all”. If your workflow shows you that the fixed paths keep falling short, you have a data-driven reason to open the dial. Starting on the right and hoping for the best is the opposite of that.

Evals in CI: When AI features stop being prompts
... and start being software - with all the testing obligations that come with it
rubeen.dev/en/blog/ai-evals-ci-pipeline
→

Klarna is the publicly reported counterpart, the dial turned the other way. In 2024, the company automated its support broadly: according to Klarna, the assistant handled 2.3 million conversations in its first weeks, two thirds of all service chats, doing the work of around 700 full-time agents. Not a free-form agent loop, but routing and triage plus self-service for clearly bounded requests; complex cases went to humans. In 2025 came the correction. AI-first-by-default was cheaper, but delivered worse quality, so Klarna started hiring humans again and walked things back to a hybrid model with humans as the default. They didn’t get rid of the AI, they just let it run less autonomously. The setting can be moved in both directions: you open it with data and pull it back when quality demands it.

If you’ve come along this far, you probably have a few objections ready. The loudest one first: doesn’t a better model make all this scaffolding unnecessary anyway?

Common objections

When I argue for structured architecture instead of free-form loops, four objections reliably come back. They’re all good - and none of them topples the thesis. The loudest one first.

“The Bitter Lesson: your scaffolding will be made obsolete by the next model.”

In 2019, Rich Sutton laid out the bitter lesson: “general methods that leverage computation are ultimately the most effective, and by a large margin.” Dean Ball brings it to today: you can put a lot of time into scaffolding that gets current models working in production, only for the next generation to manage without it. True - for capability scaffolding, meaning everything that teaches the model how to think or break down a task. Control scaffolding is a different category: what may be executed, what gets logged, how big the blast radius is. A better model doesn’t make delete_account any less irreversible. You’re not constraining the intelligence, you’re constraining the consequences.

“But Anthropic’s multi-agent research beats single-agent by 90%.”

The 90.2% from the last section comes back here as an objection - and sounds sharper that way. The number is real: a multi-agent system with an Opus 4 lead and Sonnet 4 subagents against a single Opus 4, on Anthropic’s internal research eval. It applies to broad, parallelizable research where you pursue many independent directions at once. Cognition argues the opposite: for connected, context-critical tasks, several collaborating agents become fragile, because context can’t be shared cleanly between them. Both are right; it depends on the class of task - Anthropic itself admits that most coding tasks are far less parallelizable than research. The fact that this debate is happening at all is the best evidence that there is no default.

Cognition vs. Anthropic: the multi-agent debate in 60 seconds

Anthropic (pro multi-agent): For breadth-first research, a lead agent with subagents clearly beat the single agent. Several agents follow independent leads in parallel, and the token cost (about 15x more than a chat) pays off because the value of the task is high.

Cognition (contra multi-agent): Several collaborating agents create fragile systems, because decisions are scattered and context isn’t shared throughout. In the Flappy Bird example, one subagent builds the background in Super Mario style while another builds the bird - the pieces don’t fit together.

Resolution: These are two classes of task. Parallelizable and independent speaks for multi-agent; connected and context-critical speaks for a single agent or a structured flow.

C
Don’t Build Multi-Agents
Frameworks for LLM Agents have been surprisingly disappointing. I want to offer some principles for building agents based on our own trial & error, and…
cognition.ai
→
A
How we built our multi-agent research system
On the the engineering challenges and lessons learned from building Claude's Research system
anthropic.com
→

“That much structure is over-engineering and takes the magic away from the model.”

The model stays in the game where judgment counts: classification, extraction, ambiguity, synthesis. What you take away from it is flow control, and code does that more reliably than any heuristic in the prompt. Over-engineering would be replacing a deterministic switch with an agent loop because it sounds more modern. The magic is still at the decision point; everything around it is just what keeps it from being squandered.

“That’s just workflow programming with a new name.”

Partly, yes - and that’s the point. Nodes, edges, switches, guards have been around for decades. The structure is old; what’s new is the discipline of using the model inside that structure at exactly the points where its judgment contributes something, and nowhere else. If you dismiss that as “just workflow”, you’ve already grasped the expensive part and only need to take it seriously.

Four objections, no knockout. What remains is a question of dosage: how much loop this one task really needs. And you’re most likely to answer that by handing out as little autonomy as necessary.

Least agency, taken to its conclusion

The debate from the last section has no winner, and that’s the real punchline: there’s no default level of autonomy you can just adopt. Cognition and Anthropic don’t contradict each other by accident; they’re talking about different classes of task. You choose the dial setting - per task, with a reason. And a better model doesn’t make that choice for you: it doesn’t make a destructive action any less destructive. The idea isn’t new in this series; it’s just moved up a floor.

The human-in-the-loop post was about least agency at the action level: the loop runs, but at the risky point an approval gate stops it and brings in a human. This post starts one level earlier. Instead of braking the loop at one point, it asks how much loop needs to exist at all. A decision point in a structured flow is an action the model never gets free rein over in the first place. Both are the same principle, only as much autonomy as the task requires: once at the action, once at the architecture.

With that, the previous posts in the series click into place. Each one pulled a different lever, all in the same direction. Seven predecessors, one operating model - this one ties them together:

Evals, rollout, and the incident loop catch errors after they’ve happened. Approval stops them before they take effect. The loop architecture this post was about decides one stage earlier: how many errors can happen in the first place. Every step the loop doesn’t take is one less step that’s only 99% likely to be right. Ten of those steps, and 99% turns into 90%. And a delete_account that never sits next to unsubscribe_marketing in the free choice space is an entire failure class that no eval has to catch and no approval has to stop anymore.

Approval Isn't a UX Bug: Why Agent Systems Need to Know When to Ask
Human in the loop isn't a weakness, it's security architecture. Why pause/resume for critical agent actions may be the most important feature of all.
rubeen.dev/en/blog/human-in-the-loop
→
Tools Aren't Prompts: Why Agent Actions Need Idempotency, Auth, and Audit
A tool call can move money and change accounts. Why idempotency, auth, and audit in agent architectures aren't a nice extra but a hard requirement.
rubeen.dev/en/blog/tools-sind-keine-prompts
→
From Incident to Regression Test: How Production Failures Make Their Way into Your Eval Set
An eval suite that doesn't grow with your incidents shrinks relative to reality. What the postmortem-to-eval loop looks like in practice, from the trace ID to the required field in the postmortem template.
rubeen.dev/en/blog/incident-zu-regressionstest
→

This isn’t an anti-agent manifesto. There are tasks that really need the open loop - open-ended research, creative synthesis, anything where the subtasks only show up while you’re working. There, structure is a cage, and a free-form agent wins. But that stays the exception. The mistake is rarely building an agent loop. It’s taking it as the obvious starting point instead of justifying it.

If you take this seriously, you start your next feature with the narrowest architecture that does the job and only open the dial when evals and rollout data justify it. That’s more work up front and fewer surprises in operation.

The tools post had a sentence that applied at the level of a single call: the LLM doesn’t execute, the system does. One floor up, at the level of the whole flow, it applies once more. The model delivers judgment at the points where judgment counts. The code owns the flow.

The LLM doesn’t steer, the system does.