Part V of 5 · Chapters 27 to 33

Cost decides, and the situation sets the dials

Cost is what decides between configurations. Decision rules, tools for each lever, documented cases, and the matrix that the research produces.

Chapters (7)27. Cost is what decides between two configurations28. Choosing takes three things: a structure, a situation and a measure29. For each lever: a default, a dial, its price, and the tools of 202630. A regulated enterprise and a startup turn most dials in opposite directions31. A configuration is a hypothesis until it is measured on five dimensions32. A place to start: a bug-triage pipeline for a mid-sized team33. The result: a situational matrix, a frontier that moves, and five gaps

27. Cost is what decides between two configurations

Four parts of this report have arrived, by different roads, at the same question.

Part II found one loop under every methodology, then eight levers that describe how two systems differ. Chapter 15 showed the limit of that description: the levers say where a tree-search agent and a while loop part ways, and they cannot say which one to build. Part III read the catalogue of patterns, frameworks and protocols as settings of those levers, and found that no vendor publishes a measurement comparing one setting with another. Part IV traced these structures to their origin. They come from us. Roles, procedures, reviews and hierarchies were borrowed from human organizations because those were the only working models of coordinated, fallible labor anyone had. Where the borrowing breaks, a substitute can usually be engineered, and it has a price.

Each road ends on the same words: at what cost? This chapter takes that question as the answer. Architecture describes the difference between two methodologies. What decides between them is what each one costs, in tokens, in time, and in human attention.

Figure 27.1: Three columns for the three costs of an agentic system, tokens, latency and human attention, above a strip for the price of safety. Figure 27.1: The three costs of an agentic system, tokens, latency and human attention, with what this chapter’s sources measure of each, drawn by this report. The two percentages are vendor-reported (Anthropic, Anthropic), and the price of safety is the one measured for CaMeL (arXiv 2503.18813).

Tokens come first because they are the best measured. Anthropic analysed its own multi-agent research system on BrowseComp, an evaluation of hard-to-find information on the web. Three factors explained 95 % of the variance in performance. Token usage by itself explained 80 %, and the number of tool calls and the choice of model accounted for the rest of that share (Anthropic). The same post gives the multipliers. An agent uses about four times more tokens than a chat exchange, and a multi-agent system about fifteen times more. Read together, the two figures say something uncomfortable about architecture. A design that performs better while spending fifteen times more has not yet shown that its structure is what helped.

Latency is the second cost, and the least documented. Cutting a task into sequential steps, as chapter 9 reported, trades latency for accuracy, and that trade is the stated purpose of the pattern. Every verification pass and every hand-off between agents adds its own delay. No source in this corpus measures that delay across architectures, so it enters the argument as a known direction without a known size.

Human attention is the third, and the one most often left off the bill. It is spent twice. It is spent first on supervision: operators approved roughly 93 % of permission prompts in Anthropic’s telemetry, the sign of attention that has run out (Anthropic). It is spent again, earlier and less visibly, on making tacit knowledge explicit. What a team knows without writing it down has to be written before an agent can use it, and chapter 6 showed that this work falls on the most experienced people.

Safety has a price in the same currency. CaMeL, the defense that makes injected instructions structurally ineffective, completes 77 % of tasks where an undefended system completes 84 % (arXiv 2503.18813). Seven points of utility are the cost of a guarantee. Detection-based defenses appear to cost nothing, and twelve of them fell at rates above 90 % once the attacker adapted (arXiv 2510.09023). The cheap option was not a defense.

Why does cost decide where architecture does not? Because, in the present state of the evidence, architecture cannot be judged apart from spending. No study in this corpus compares two methodologies with the same model and the same token budget. Until one does, any claim that a structure performs better remains entangled with the fact that it consumed more.

Figure 27.2: A staircase of three steps, a chat exchange, an agent and a multi-agent system, each as tall as the tokens it spends. Figure 27.2: Tokens spent by a chat exchange, an agent and a multi-agent system, drawn by this report from the multipliers one vendor publishes (Anthropic). The return on each step has not been measured at constant model and budget.

This conclusion is easy to misread, in two ways. It does not say that the cheapest design is the right one. A cost is paid for something: wider reach, a lower risk of an irreversible error, a task that could not be done otherwise. And it does not say that structure is irrelevant. The levers remain the only vocabulary in which a design can be described, compared and changed. What the conclusion says is narrower. Structure tells a designer what the options are, and cost tells them what each option takes.

Whether a given cost is worth paying is not a property of the system. It depends on who pays and on what a failure would cost them. A bank and a three-person startup can look at the same fifteen-fold multiplier and both be right to answer differently. The practical rule that follows is the one Anthropic gives its own customers: find the simplest solution possible, and add complexity only when it demonstrably improves the outcome (Anthropic). Every lever turned up has to earn back what it spends.

The reserve on this chapter is the same as on its sources. The 80 %, the multipliers and the 93 % all come from one vendor’s telemetry on its own products. They give orders of magnitude and a direction. They are not independent measurements, and the exchange rate between complexity and performance stays approximate until someone measures it at constant model and budget.

Cost, then, is where the analysis ends and where the design work begins. If the right setting depends on the situation of whoever pays, the next step is to describe situations with the same care this report gave to levers. The following chapters do that.

28. Choosing takes three things: a structure, a situation and a measure

Parts II through IV of this report built the analytical machinery. Eight levers decompose any agentic methodology into adjustable design dimensions. The organizational transposition showed where human structures map onto agent architectures and where they do not. The economic analysis established that token consumption explains 80% of performance variance and that cost, not architectural elegance, is the primary separator (Anthropic). All of this is necessary. None of it is sufficient. A framework that describes everything and prescribes nothing leaves the architect exactly where the field left them: facing a proliferation of tools with no principled way to choose.

This chapter closes that gap. It introduces the triangle that governs the rest of Part V: Structure, the eight levers as adjustable dials; Situation, the organizational context that determines where each dial should point; and Measure, the multidimensional instrument that tells the architect whether the configuration works. By the end of these final chapters, the reader should be able to place the right tools in front of their specific situation and verify the result.

Figure 28.1: A triangle with Structure at the top, Situation and Measure at the base, and an arrow from each base corner up to Structure. Figure 28.1: The triangle of structure, situation and measure, drawn by this report. The situation determines where each dial should point, and the measure, the CLEAR framework (arXiv 2511.14136), tells whether the configuration works.

The eight levers are not rules. They are questions. Context asks what the agent knows when it decides. Action capability asks what it can do irreversibly. The control loop asks whether the model or the code drives the next step. Each question admits a spectrum of answers, from fully deterministic to fully autonomous, and that spectrum is what makes the framework useful. A single organization does not answer all eight questions the same way. An enterprise deploying a compliance workflow will lock the Control loop lever to deterministic code while opening the Verification lever to its widest setting. A startup shipping a research assistant will do the opposite: let the model drive the loop and rely on lightweight post-hoc review. The levers do not prescribe the answer. The situation does.

What varies from one organization to another is not the technology. The same LLM, the same orchestration framework, the same sandbox can serve radically different architectures. What varies is the organizational context, and it varies along four dimensions that sit above the economics.

The first is risk tolerance: what does failure cost? In a regulated industry, a single hallucinated compliance report can trigger a regulatory investigation. The cost of failure is measured in legal liability, not in tokens. In a startup prototyping a feature, the cost of failure is a wasted afternoon. Risk tolerance determines how far the levers of Action capability, Verification, and Human control must be tightened. Singapore’s Model AI Governance Framework for Agentic AI, which its publisher presents as the first governance framework designed for agents, builds on the same principle. It asks organizations to assess each use by the likelihood and the severity of what could go wrong, and to make human review proportionate to that risk (IMDA).

The second is process predictability: can the workflow be defined in advance? A loan approval pipeline follows a fixed sequence of steps. A research task does not. Predictability determines the setting of the Control loop lever and the Decomposition lever. Where the process is predictable, deterministic orchestration eliminates an entire class of failure modes. Where it is not, the model must drive the loop, and the coordination cost must be paid.

The third is human attentional budget: how much oversight capacity does the organization have? Anthropic’s telemetry established that users approve 93% of permission prompts once the volume overwhelms their attention (Anthropic). A large enterprise with a dedicated oversight team can sustain more human gates than a solo founder who is also the product manager, the engineer, and the customer. The attentional budget determines how the Human control lever is set: frequent high-friction gates for the enterprise, rare circuit-breaker gates for the startup.

The fourth is velocity requirement: how fast must the system ship and iterate? A team that needs to deploy in days cannot afford weeks of governance review. Velocity determines the balance between the Capability evolution lever, the State persistence lever, and the overall weight of the scaffolding. Light scaffolding ships fast and breaks in ways that heavy scaffolding would have caught. The tradeoff is real and must be acknowledged, not hidden.

These four criteria do not replace the economic boundary established in Chapter 27. They sit on top of it. Two organizations with the same token budget will produce different architectures because their risk tolerance, process predictability, attentional budget, and velocity requirements differ. The economics set the floor. The situation shapes the room.

The third side of the triangle is measurement. Knowing which levers to set and why is not enough if the architect cannot verify that the configuration works in production. The field’s dominant evaluation metric, task completion accuracy measured on a single run, is a poor predictor of readiness for production. A study of twelve benchmarks and six agents asked experts to rate how ready each agent was for deployment. Accuracy alone correlated with those ratings at only 0.41. The multidimensional CLEAR framework (Cost, Latency, Efficacy, Assurance, Reliability) correlated at 0.83 (arXiv 2511.14136). The gap is not marginal. An architect who optimizes for accuracy alone will deploy agents that cost 4.4 to 10.8 times more than cost-aware alternatives with comparable performance.

CLEAR provides five dimensions that map directly onto the concerns raised throughout this report. Cost captures the token and compute expenditure that Chapter 27 established as the primary discriminator. Latency captures the time-to-completion that matters for real-time and user-facing workflows. Efficacy captures the functional success rate. Assurance captures policy compliance, guardrail adherence, and security posture. Reliability captures consistency across repeated runs, a dimension the field has systematically neglected. The CLEAR paper cites an earlier benchmark on consistency. Agents that succeed 60% of the time on a single run succeed only 25% of the time when they must succeed eight times in a row (arXiv 2511.14136). A single lucky pass is not a deployment-ready system.

The chapters that follow will fill each side of the triangle. Chapter 29 opens the mixing board: for each lever, the default setting, the situational dial, the cost of turning it, and the concrete tools from a catalogue of 242 entries across 31 technology layers that implement each position. Chapter 30 assembles two contrasting profiles, an industrial enterprise and an agile startup, and maps them across all eight levers with specific tool choices and measurement targets. Chapter 31 operationalizes the CLEAR dimensions into a practical measurement protocol. Chapter 32 presents a reference instantiation for a mid-complexity team. Chapter 33 gathers the result into one matrix, shows how fast its settings are moving, and states what the methodology cannot yet do.

29. For each lever: a default, a dial, its price, and the tools of 2026

The eight levers are the dials of the situational architecture, and this chapter is the mixing board. For each lever it gives a default setting, the position that costs least and risks least. It then names the situational criterion that justifies turning the dial up, and what turning it costs. Finally it ties each position to tools that exist in 2026.

That last step needs a map of the tools. The one used here is the Agentic AI Stack 2026 catalogue, a working index compiled by the author for this report in July 2026 from web research. It lists 242 tools sorted into 31 layers, from IDE extensions to registries, and marks each tool as a standard choice, an alternative, or one to approach with caution. The catalogue is a practitioner’s inventory, not a benchmark. It records what exists and what is commonly chosen, and it measures nothing. The layer numbers below are the catalogue’s own.

An architecture is not a collection of tools. It is a set of answers to the eight questions, and the tools come afterwards, as the means of holding each answer in place.

Lever 1: Context (What the agent knows)

The default setting: Just-in-time retrieval. The agent is given only the context needed for the step in front of it.

The situational dial: Process predictability. When a task is open-ended, the agent needs a wider window to reason about dependencies nobody listed in advance.

The cost: Tokens, and the dilution described in chapter 6. Feeding a whole codebase into the prompt degrades reasoning on the instruction that matters.

The tool mapping (Layers 12, 18 to 21, 29): The default is built from document ingestion (Layer 18), embeddings (Layer 19) and a vector store (Layer 20), with native prompt caching (Layer 12) to avoid paying twice for the same prefix. Turning the dial up adds reranking (Layer 21) and code intelligence (Layer 29), which widen what the agent can reach without widening what it must read.

Table 29.1 Representative tools for the Context lever

Tool Layer What it does Why it sits on this lever
Docling 18. Document ingestion Converts PDF, Word, slides and HTML into Markdown or JSON, with OCR Decides the form in which documents enter the window
BGE-M3 19. Embeddings One model producing dense, sparse and multi-vector representations Determines what retrieval is able to find
pgvector 20. Vector store Vector search inside Postgres Holds what can be fetched just in time
Cohere Rerank 4 21. Reranking Managed multilingual reranking of retrieved passages Keeps only the highest-signal passages in the window
Native prompt caching 12. Caching and cost Reuses a repeated system prefix at a reduced rate Lowers the price of context that does not change

Lever 2: Action capability (What it can do irreversibly)

The default setting: Read-only, with a human executing. The agent proposes and a person applies.

The situational dial: Velocity requirement and risk tolerance. High velocity calls for write access. Low risk tolerance calls for strict containment of that access.

The cost: Exposure. An agent that can write can damage, and chapter 7 showed that a demonstrable guarantee costs utility, seven points in the one case measured.

The tool mapping (Layers 7, 8, 9): The default needs no tools. Turning the dial up requires an execution sandbox (Layer 9) before anything else. Identity and authorization (Layer 7) then settle on whose behalf the agent acts, and browser and web tooling (Layer 8) extends its reach outside the workspace. Granting write access without a sandbox layer cancels every other safeguard.

Table 29.2 Representative tools for the Action capability lever

Tool Layer What it does Why it sits on this lever
E2B 9. Execution sandbox Isolated Linux sandboxes for generated code Sets the perimeter outside which the agent can reach nothing
Firecracker 9. Execution sandbox The microVM layer underneath several sandbox services The same perimeter, for teams that want to control it directly
OAuth 2.1 with Dynamic Client Registration 7. Identity and authorization Issues tokens to agents at run time Bounds what an agent is permitted to call
Arcade 7. Identity and authorization Per-user OAuth with just-in-time consent and a token vault Ties each action to the user it is taken for
Browser Use 8. Browser and web data A Python browser agent that reads the page structure Extends action to the open web, where containment is hardest

Lever 3: Control loop (Who drives the next step)

The default setting: Deterministic orchestration. A state machine or a script fixes the sequence, and the model is called for specific tasks inside it.

The situational dial: Process predictability. If the workflow cannot be written in advance, as in open-ended research, the loop has to be handed to the model.

The cost: Unbounded execution. A model-driven loop can retry without end, and its path cannot be predicted.

The tool mapping (Layers 2, 3, 4, 27): Code-driven loops run on classic workflow orchestrators (Layer 27) or on durable execution engines (Layer 4). Model-driven loops run on orchestration frameworks (Layer 3), or are handed whole to an autonomous code agent (Layer 2).

Table 29.3 Representative tools for the Control loop lever

Tool Layer What it does Why it sits on this lever
Prefect 27. Classic workflow orchestrator Scheduling, retries and observability for scripted workflows Code decides the sequence, the default position
LangGraph 3. Orchestration framework Stateful cyclic workflows with checkpointing Lets a designer say, node by node, whether code or the model decides
Pydantic AI 3. Orchestration framework Type-safe agents with typed contracts end to end Bounds a model-driven step inside a code-driven flow
Claude Agent SDK 3. Orchestration framework Agents with built-in file and shell tools Hands the loop to the model inside a prepared harness
Claude Code 2. Autonomous code agent Autonomous multi-file edits The fully model-driven end of the dial

Lever 4: Decomposition (How the work is divided)

The default setting: The single-writer principle. One agent holds the context and writes the output. If it needs help it calls tools, not peers.

The situational dial: Task complexity and attentional budget. When a task needs contexts that work against each other, such as writing code and reviewing it as an adversary, splitting it across specialized agents becomes necessary.

The cost: Coordination. Multi-agent systems consume about 15× more tokens than chat exchanges (Anthropic).

The tool mapping (Layers 2, 3, 6): The default is a single autonomous code agent (Layer 2). Turning the dial up means using the multi-agent features of an orchestration framework (Layer 3), or routing between agents over a protocol (Layer 6).

Table 29.4 Representative tools for the Decomposition lever

Tool Layer What it does Why it sits on this lever
CrewAI 3. Orchestration framework Teams of agents defined by roles and tasks Cuts the work by role
Microsoft Agent Framework 3. Orchestration framework The merged successor of AutoGen and Semantic Kernel Offers orchestrated multi-agent patterns with checkpointing
OpenAI Agents SDK 3. Orchestration framework Lightweight multi-agent runtime with tracing and guardrails Makes the choice between specialists as tools and handoffs explicit
Google ADK 3. Orchestration framework Agent development kit with workflow and model-driven agents Lets the cut be written in advance or left to an orchestrator
A2A 6. Protocol and standard Communication between agents across organizational boundaries Carries a division of labor that crosses systems

Lever 5: Verification (How output is checked)

The default setting: Deterministic checks. Code is checked by compilers and tests, and data by schemas.

The situational dial: Risk tolerance. When a subtle error is expensive and no compiler can catch it, as in a strategic analysis, a model has to be added as a judge.

The cost: Tokens, latency and false alarms. A model that judges has its own error rate and triggers retries that were not needed.

The tool mapping (Layers 13, 14, 15, 22): The default relies on structured output (Layer 22) and ordinary continuous integration. Turning the dial up adds evaluation suites (Layer 14), guardrails that intercept violations in flight (Layer 15), and observability (Layer 13) to record the calls that chapter 10 said to audit.

Table 29.5 Representative tools for the Verification lever

Tool Layer What it does Why it sits on this lever
Instructor 22. Structured output Validated structured data from model outputs, with automatic retries The deterministic check on the shape of an output
DeepEval 14. Evals Test-style evaluations for models and agents Checks output quality against a set of cases
promptfoo 14. Evals Declarative evaluation scenarios in configuration files Makes a regression in behavior visible before release
NeMo Guardrails 15. Guardrails Input and output rails defined in a dedicated language Intercepts a policy violation at the point of execution
Langfuse 13. Observability Hierarchical traces of calls, with evaluations and cost Records the actions on which an audit has to rest

Lever 6: State persistence (What survives the session)

The default setting: Session-scoped memory. State ends when the run ends.

The situational dial: Process predictability and velocity. If a task spans days, or has to resume after a human intervenes, state must be made durable.

The cost: Complexity and data governance. Persisted agent memory is a second database, to be secured and purged like any other.

The tool mapping (Layers 4, 10): The default needs no tools. Durable persistence calls for a memory layer (Layer 10) and for durable execution (Layer 4), which replays a workflow from the step that failed without repeating the model calls that succeeded.

Table 29.6 Representative tools for the State persistence lever

Tool Layer What it does Why it sits on this lever
LangGraph checkpointers 10. Memory Saves graph state to Postgres, Redis or DynamoDB Gives a thread back exactly where it stopped
mem0 10. Memory Persistent memory scoped to a user, a session or an agent Carries facts across sessions
Zep / Graphiti 10. Memory A knowledge graph of facts with periods of validity Keeps long-term knowledge, with compliance certifications
DBOS 4. Durable execution Durability through Postgres, with replay from the last step Decides what a crash loses
Cloudflare Workflows 4. Durable execution Durable multi-step execution on a serverless platform The same guarantee without new infrastructure

Lever 7: Capability evolution (How the agent improves)

The default setting: Static prompts and curated skills. What the agent can do is written by people and changed by people.

The situational dial: Attentional budget. If the team cannot update prompts by hand for every edge case, part of that work has to be automated.

The cost: Predictability. A system that rewrites its own prompts or weights drifts, and the drift has to be evaluated.

The tool mapping (Layers 5, 24, 30): The default uses agent skills and plugins (Layer 30). Evolution comes first through optimization (Layer 5), which rewrites prompts from execution traces, and only then through fine-tuning (Layer 24), which is heavier and harder to reverse.

Table 29.7 Representative tools for the Capability evolution lever

Tool Layer What it does Why it sits on this lever
AGENTS.md 30. Agent skill and plugin A project context file read by coding agents The static, human-written form of capability
skill-creator 30. Agent skill and plugin Creates, edits and evaluates agent skills Adds a capability under human review
DSPy 5. Optimization Declarative pipelines whose prompts are optimized by program Changes the decision policy without touching weights
GEPA 5. Optimization Optimizes prompts by reflecting on execution traces Turns past runs into a revised instruction
Unsloth 24. Fine-tuning Faster, lighter fine-tuning with adapters Changes the weights, the most durable and least reversible site of evolution

Lever 8: Human control (When the human intervenes)

The default setting: A gate before each consequential action. The agent asks before it does anything that matters, and such gates are kept few, as chapter 13 requires.

The situational dial: Attentional budget and velocity. As volume grows, people approve without reading, at the 93 % rate already cited. Control then has to move from gates before the action to containment, review after the fact and circuit breakers.

The cost: Damage that has already happened. Review after the fact finds an error once it is in production.

The tool mapping (Layers 1, 26, 28): Step-by-step approval is built into IDE extensions (Layer 1). Review after the fact needs an agent interface (Layer 26), or a low-code and visual builder (Layer 28) in which a person can follow executions and adjust rules without stopping them.

Table 29.8 Representative tools for the Human control lever

Tool Layer What it does Why it sits on this lever
Cline 1. IDE extension An open-source coding agent with plan and act modes and approval per step The gate-before-action setting, at its most frequent
CopilotKit 26. Agent interface Interface components with human-in-the-loop support and an inspector Builds the surface on which a person sees and intervenes
assistant-ui 26. Agent interface Composable interface primitives for agent applications The same surface, assembled piece by piece
Gradio 26. Agent interface Quick web interfaces A review screen that can be stood up in an afternoon
n8n 28. Low-code and visual Visual workflows with a clear execution log Lets a non-developer follow and correct what agents did

Where the 31 layers of the catalogue fall on the eight levers

Table 29.9 gathers the mapping in one place. An architect sets each lever from the situation, then picks from the layers on that row. The layer numbers are those of the catalogue, whose full index is in the spreadsheet that accompanies this report.

Table 29.9 The catalogue's layers set against the eight levers

Lever Layers for the default setting Layers added when the dial is turned up
1. Context Ingestion (18), Embeddings (19), Vector store (20), Caching (12) Reranking (21), Code intelligence (29)
2. Action capability None Sandbox (9), Identity and authorization (7), Browser and web data (8)
3. Control loop Classic workflow orchestrator (27), Durable execution (4) Orchestration framework (3), Autonomous code agent (2)
4. Decomposition Autonomous code agent (2) Orchestration framework (3), Protocol and standard (6)
5. Verification Structured output (22) Evals (14), Guardrails (15), Observability (13), Security and red teaming (16)
6. State persistence None Memory (10), Durable execution (4)
7. Capability evolution Agent skill and plugin (30) Optimization (5), Fine-tuning (24)
8. Human control IDE extension (1) Agent interface (26), Low-code and visual (28)

Five layers appear on no row: model gateways (11), mechanistic interpretability (17), local serving and inference (23), voice and real-time agents (25), and directories and registries (31). They are infrastructure or research tooling that any setting of the levers may rest on, and assigning them to a lever would be forcing the fit. The matrix is a reading aid built by this report, and like the catalogue it draws on, it has not been tested against outcomes.

The next chapter turns all eight dials at once, for two organizations that could hardly differ more.

30. A regulated enterprise and a startup turn most dials in opposite directions

The previous chapter gave each lever a default and a dial. This one turns all eight at once. What does a complete configuration look like for one organization, and how different is it for another? Two profiles answer that question, a regulated enterprise and a small startup. Each is then set beside a documented deployment, to check that the settings described here exist outside this report.

The profiles are constructions. They were built by applying the four situational criteria of chapter 28 to the decision rules of chapter 29, and their tool choices come from the catalogue. They show how the reasoning runs. They do not describe any particular company.

Figure 30.1: Two workshops drawing on the same wall of tools. Figure 30.1: Two workshops take their tools from the same wall, an editorial allegory for this chapter: a careful team around a precise machine, and a lone builder already on the move. The two profiles that follow are constructions of this report, read against the CLEAR dimensions (arXiv 2511.14136).

Profile A: the industrial enterprise

The first profile is a large organization in a regulated industry, such as finance or healthcare. Its situation reads as follows on the four criteria.

  • Risk tolerance: Extremely low. An error carries legal liability and damages reputation.
  • Process predictability: High. Workflows such as compliance checks or loan processing are rigidly defined.
  • Attentional budget: High. The organization has teams dedicated to governance and oversight.
  • Velocity requirement: Low to medium. Safety and compliance matter more than shipping tomorrow.

A situation of that kind produces a defensive, deterministic architecture. In the terms of the next chapter, it favors assurance and reliability over cost and speed.

  • 1. Context: Highly curated. The system relies on enterprise-grade ingestion (Unstructured) and strictly isolated vector databases (Milvus or Weaviate), so that data boundaries are never crossed.
  • 2. Action capability: Strictly contained. All execution happens within an enterprise sandbox (E2B Enterprise), with dry runs and full filtering of outbound traffic.
  • 3. Control loop: Deterministic. Code orchestrates the workflow. A tool like LangGraph is used as a rigid state machine in which the model only carries out specific classification or extraction steps.
  • 4. Decomposition: The single-writer principle, with read-only subagents. An orchestration loop hands narrow tasks to specialized workers, and a single node assembles the final state.
  • 5. Verification: Maximum stringency. Evaluations (DeepEval, Braintrust) run continuously, and guardrails (NeMo Guardrails, Galileo) intercept policy violations before they reach the user.
  • 6. State persistence: Durable and audited. Durable execution logs every step and resumes exactly where a run failed, and a memory layer with compliance certifications (Zep / Graphiti) holds what must outlive the task.
  • 7. Capability evolution: Controlled. Capabilities change through procedures approved by people and through prompt optimization (DSPy) gated by evaluation suites. Nothing improves itself unattended.
  • 8. Human control: Gates before consequential actions. The agent cannot commit a transaction or send an external communication without explicit approval, and those gates are placed at a few key points, as chapter 13 requires.

A documented case on the code-governed side: Stripe Stripe, the payments company, has described the coding agents it runs internally, which it calls Minions (Stripe). Their loop is governed by what Stripe calls a blueprint, “a collection of agent skills interwoven with deterministic code”: steps such as running the linters are fixed nodes, and the model works between them. Each agent runs in an isolated development machine, so that “any mistakes an agent might make are confined to the limited blast radius of one devbox”. After the second push and run of automated checks, the branch goes “back to its human operator for manual scrutiny”. Stripe reports more than 1,300 merged pull requests a week written this way, all of them reviewed by people.

The Stripe case matches Profile A on three levers: a control loop held by code, containment decided before the action, and a human gate at a fixed point. It departs from it on a fourth. Inside its sandbox, the Stripe agent runs with full permissions, which is the wide setting of the Action capability lever, made acceptable by the perimeter around it. The case is also an internal engineering tool, and says nothing about a regulated decision that affects a customer.

Profile B: the agile startup

The second profile is a small, fast-moving team building an internal tool or an early product.

  • Risk tolerance: High. A wrong output costs little compared with moving slowly.
  • Process predictability: Low. The tasks are open-ended, such as deep research or code generation.
  • Attentional budget: Very low. A small team cannot watch hundreds of agent runs by hand.
  • Velocity requirement: Extremely high. The system must be deployed and changed quickly.

The architecture that follows is fluid and autonomous. It favors cost and efficacy.

  • 1. Context: Broad and dynamic. The system uses lightweight ingestion (Docling) and a fast local vector store (pgvector).
  • 2. Action capability: Read and write. The agent has broad permissions inside a standard sandbox (E2B), where it can run code and test its own hypotheses.
  • 3. Control loop: Model-driven. The agent decides the sequence of steps, planning and iterating by itself through an SDK (Claude Agent SDK, Vercel AI SDK).
  • 4. Decomposition: A single agent. The team avoids the 15× token overhead of multi-agent systems and relies on one capable frontier model with a broad set of tools.
  • 5. Verification: Lightweight. The system relies on basic assertions and on the model correcting itself, with no heavy external guardrails.
  • 6. State persistence: Session-scoped. State lives in the context window or in a light memory tool (mem0), and is reset for each new task.
  • 7. Capability evolution: Rapid and empirical. The team edits system prompts directly and adds tools through MCP servers as needs appear, trusting fast feedback more than formal evaluation gates.
  • 8. Human control: Review after the fact. The agent works unattended within its domain. People read a daily summary, or respond when the agent escalates a failure it cannot resolve.

A documented case on the model-driven side: Shopify Shopify has described how it built Sidekick, the assistant that helps merchants manage their stores (Shopify). Its loop is the open one: the model “decides on actions, those actions are executed in the environment, feedback is collected, and the cycle continues until the task is complete”. Its advice on decomposition is blunt: “Avoid multi-agent architectures early: Simple single-agent systems can handle more complexity than you might expect”. Context is supplied just in time, with instructions returned “alongside tool data exactly when they’re needed”. Verification rests on model judges, which the team calibrated from an agreement with human raters barely better than chance to one close to the agreement between humans.

Shopify is no startup, and the case is cited for its settings, not for the size of the company. It matches Profile B on the control loop, on decomposition and on context. It departs from it on verification, where Shopify invested heavily. That departure is instructive. A team that hands the loop to the model tends to pay it back in evaluation.

Figure 30.2: The two profiles, criterion by criterion and lever by lever. Figure 30.2: The two profiles of this chapter side by side, drawn by this report from the lists above: the situation on the four criteria of chapter 28, then the setting of each lever. Both are constructions, to be read against the CLEAR dimensions of the next chapter (arXiv 2511.14136).

The two profiles could run on the same model and would still share almost nothing else. Their situations call for opposite positions on most of the eight dials, which is the claim chapter 28 set out to make concrete.

Neither documented case fits its profile exactly, and that is the second lesson of the chapter. Real systems mix settings: a code-governed loop with wide permissions, or a model-driven loop with heavy evaluation. No published account read for this report describes a deployment on all eight levers, so each case confirms a few rows and leaves the others blank.

A configuration is a hypothesis until someone measures whether it works. The next chapter supplies the instrument.

31. A configuration is a hypothesis until it is measured on five dimensions

The previous chapters established how to set the eight architectural levers based on situational constraints. But an architecture is only a hypothesis until it is measured. The field has historically relied on a single, flawed metric: task completion accuracy on a single benchmark run. This metric is a poor guide for production deployments.

Figure 31.1: A model engine under glass, a working train, and a surveyor measuring the gap between them. Figure 31.1: A model engine under glass and a working train, with a surveyor measuring the gap between them, an editorial allegory by this report. A score obtained once on a benchmark says little about behaviour in production, which is the argument of the CLEAR framework (arXiv 2511.14136).

A systematic analysis of twelve major benchmarks and six leading agents found that accuracy alone correlates with experts’ ratings of deployment readiness at only ρ=0.41 (arXiv 2511.14136). A metric that tracks expert judgement so loosely is a weak basis for an enterprise system. The same analysis reports that optimizing an agentic system for accuracy alone produces configurations that cost 4.4 to 10.8 times more than cost-aware alternatives while delivering comparable functional utility.

To replace this flawed standard, this report adopts the multidimensional CLEAR framework (Cost, Latency, Efficacy, Assurance, Reliability). When these five dimensions are measured together, the correlation with those expert ratings rises to ρ=0.83 (arXiv 2511.14136). These figures come from a single paper and have not been replicated. They are used here as the best available instrument, not as settled fact. The situational triangle introduced in Chapter 28 uses the CLEAR framework as its measurement vertex because it operationalizes the tradeoffs inherent in the eight levers.

Figure 31.2: Five equal cells, one for each CLEAR dimension, each holding the measure used for it in production, joined by one bracket. Figure 31.2: The five CLEAR dimensions (arXiv 2511.14136) and the measure this chapter gives for each in production, drawn by this report.

To guide engineering decisions, each dimension must be measured in a production setting against explicit SLAs. The following criteria define how architects evaluate and optimize these five parameters.

Cost is no longer measured purely in token volume per request, but as cost per solved task: the total spent divided by the number of tasks actually solved. This metric aggregates the token cost of the entire reasoning loop, including retries, evaluator calls, and failed attempts. A system that achieves high accuracy through infinite LLM-driven retries (turning the Control loop lever fully autonomous) will fail the CPST threshold instantly.

  • Why it’s important: Prevents runaway expenses in autonomous loops where agents might get stuck in expensive retry cycles without actually solving the task.
  • Bad example: A customer service agent that consumes $0.50 in tokens bouncing between sub-agents to answer a simple FAQ, wiping out the profit margin.
  • Good example: Setting a hard token budget per query and routing complex queries to a human if the budget is reached, keeping the cost per solved task predictable.

Latency measures the wall-clock time from the initial trigger to the final committed action. In real-time or user-facing workflows, latency is a hard constraint. Adding LLM-as-a-judge verification (turning up the Verification lever) or delegating to multiple specialized peers (turning up the Decomposition lever) significantly degrades latency. The architect must measure whether the latency budget permits these architectural choices.

  • Why it’s important: User experience degrades exponentially after a few seconds of waiting. Agents that take too long to act lose user trust or fail to meet SLAs.
  • Bad example: A real-time voice assistant that pauses for 10 seconds to run a 3-step verification chain before answering a simple user query.
  • Good example: A background data processing agent that operates asynchronously, trading high latency for high accuracy without impacting the user experience.

Efficacy replaces single-run accuracy. It measures the functional task completion rate over a statistically significant sample of real-world inputs, not static benchmarks. It is the baseline metric that proves the agent can do the job, but it is never evaluated in isolation.

  • Why it’s important: Traditional accuracy measures whether the LLM got the right answer in a vacuum, but efficacy measures whether the entire system (tools, memory, control loop) successfully accomplished the user’s goal in the real world.
  • Bad example: Measuring success by how well an agent answers multiple-choice questions on a generalized benchmark, while failing 40% of real API calls in production.
  • Good example: Tracking the percentage of user requests that are fully resolved without requiring human escalation or resulting in an error state.

Assurance measures policy compliance and security posture. It is quantified by the guardrail trip rate (how often an active guardrail intercepts a forbidden action) and the escalation rate (how often the agent hands the task back to a human). High assurance is the primary goal of the Enterprise profile described in Chapter 30, achieved by tightening the Action capability and Human control levers.

  • Why it’s important: Without assurance, agents expose the company to data leaks, brand damage, and regulatory fines. It is the metric that guarantees safety.
  • Bad example: A sales agent that hallucinates a 50% discount for a customer and commits the transaction without a human-in-the-loop check.
  • Good example: An internal HR agent that refuses to summarize documents containing PII and automatically alerts the security team when prompted to do so.

Reliability is the most neglected dimension. It measures consistency across repeated runs. The CLEAR paper, citing an earlier benchmark, reports a wide reliability gap: an agent configuration that registers a 60% success rate on a single evaluation run drops to a 25% success rate when required to succeed consistently across eight consecutive runs on the exact same task. A single lucky pass is an illusion. Production systems must be evaluated on 8-run or 10-run consistency.

  • Why it’s important: LLMs are non-deterministic. A system that works today might fail tomorrow on the exact same input. Reliability ensures the architecture is stable enough for enterprise use.
  • Bad example: An automated code reviewer that spots a vulnerability on Monday, but misses the exact same vulnerability on Tuesday because the model’s temperature caused it to focus on typos instead.
  • Good example: A data extraction pipeline that correctly pulls invoice data 10 out of 10 times because the prompt and control loop are tightly constrained and verified.

These five dimensions force the architect to acknowledge tradeoffs. If the Efficacy dimension falls below target, the instinct is to turn up the Decomposition lever (adding more agents) or the Control loop lever (giving the LLM more autonomy). The CLEAR framework forces the architect to see that doing so will immediately degrade the Cost and Latency dimensions. The measurement instrument ensures that the situation, not the technology, dictates the architecture.

The instrument is now in place beside the levers and the criteria. The next chapter uses all three on one concrete case.

32. A place to start: a bug-triage pipeline for a mid-sized team

Chapter 30 demonstrated the extremes of the situational architecture: the highly defensive Enterprise and the highly autonomous Startup. Most organizations sit between these poles. They need a system that ships fast but does not break catastrophically. They need the “if you had to pick one configuration, here is where to start” architecture.

This chapter presents that reference instantiation. To ground the tool selection and settings, we isolate a specific deployment: an internal tool for L1 technical support and triage of internal bug reports, designed for a mid-complexity engineering team (10 to 20 engineers) undertaking their first production agentic deployment.

The governing principle of this reference architecture is the spectrum of autonomy: start deterministic, and add agentic nodes only where the task strictly demands it (Anthropic).

The situation: bug triage in a mid-sized team

When an internal user submits a bug report, it must be read, reproduced if possible, cross-referenced with the codebase, and routed to the correct developer with a preliminary diagnosis. According to the four situational criteria established in chapter 28, this process profiles as follows:

  • Risk tolerance: Moderate. It is an internal operational tool, not a customer-facing application. A hallucination or a failed triage means an engineer has to manually read the ticket, creating friction but not a catastrophic data leak or reputational damage.
  • Process predictability: Semi-structured. Bug reports follow a template (steps to reproduce, expected vs. actual behavior), but the natural language varies wildly. The steps to reproduce require cognitive flexibility and cannot be entirely hardcoded.
  • Human attentional budget: Low to medium. The entire purpose of the deployment is to offload L1 triage from the engineering team so they can focus on writing features. However, engineers remain available to review the agent’s work when they actually take over the routed ticket.
  • Velocity requirement: High. Triage must happen quickly so that critical bugs are addressed without blocking the organization.

This profile dictates a configuration that prioritizes execution speed and cost-efficiency while maintaining structural safeguards.

Figure 32.1: Eight rows, one for each lever, giving its reference setting and its tool for the bug-triage case. Figure 32.1: The reference setting and the tool of each of the eight levers for the bug-triage case, drawn by this report. Code drives the macro-process and the model acts inside bounded steps, a composition of loop primitives of the kind observed in arXiv 2604.03515.

The reference setting of each lever

For a team deploying its first agentic system against a semi-structured process, the eight levers are set to balance autonomy with legibility.

1. Context (Targeted Retrieval): Dumping the entire codebase into the prompt is too expensive and dilutes the model’s attention. Instead, the context must be constructed dynamically based on the bug report’s contents.

  • Setting: Targeted RAG and strict ingestion formatting.
  • Tool: Docling (Layer 18) for clean ingestion of incoming reports, backed by a local pgvector instance (Layer 20) with standard embeddings for code retrieval. Docling ensures the messy incoming tickets are normalized into Markdown before the LLM ever sees them, reducing token waste.

2. Action capability (Containerized Read-Write): The agent needs to attempt to reproduce the bug by running code or tests. Giving it production access or direct access to the main repository is an unacceptable risk.

  • Setting: Ephemeral, isolated sandbox execution.
  • Tool: E2B Sandbox (Layer 9). The agent can write reproduction scripts, run local tests, and read logs, but the environment is destroyed after the session. It cannot reach production databases. This is what makes a moderate risk tolerance acceptable.

3. Control loop (Augmented Workflow): A fully autonomous LLM loop (like ReAct) is too brittle for a production pipeline where the macro-steps are known (read → reproduce → search → route).

  • Setting: Hybrid orchestration. Code drives the process; the model executes the nodes.
  • Tool: Temporal (Layer 4) manages the macro-process deterministically. The LLM is only granted autonomy within specific, bounded steps using a lightweight framework like Pydantic AI (Layer 3).

4. Decomposition and specialization (Tool-augmented Single Agent): The architecture rejects the overhead of multi-agent orchestration. Passing the ticket between a “Reader Agent”, a “Reproducer Agent”, and a “Router Agent” compounds latency and token costs.

  • Setting: Single frontier model equipped with specific tools.
  • Tool: A single frontier model acts as the sole router and executor. It is equipped with a tightly curated set of MCP tools (Layer 6), such as a GitHub MCP for reading code and a Jira MCP for updating the ticket.

5. Verification and conformance (Structured Output + Basic Guardrails): The system needs to ensure the output (e.g., the JSON payload routing the ticket) is perfectly formatted, but it cannot afford the latency of having a second LLM evaluate the first.

  • Setting: High structural conformity, low cognitive verification.
  • Tool: Native Structured Output (Layer 22) enforces type safety on the LLM’s payload. A small safety classifier such as Llama Guard (Layer 15) provides a basic safety net, with no general-purpose model acting as a judge.

6. State persistence (Checkpointing): If the agent fails to reproduce a bug, the entire process should not crash and start over.

  • Setting: Orchestrator-managed checkpoints.
  • Tool: Temporal’s event history natively provides checkpointing. If an LLM node encounters an API timeout, the orchestrator retries that specific node without losing the context gathered in the preceding steps.

7. Capability evolution (Static): The system must remain predictable. Autonomous self-improvement (the agent writing its own new tools) introduces non-determinism that a first deployment cannot tolerate.

  • Setting: Static capabilities with manual updates.
  • Tool: Standard Git workflows. Prompts, tools, and SOPs are updated manually by the engineers based on the agent’s failure traces.

8. Human control (Exception-based Routing): The agent runs autonomously on the happy path to preserve the human attentional budget.

  • Setting: Halt and escalate.
  • Tool: A programmatic threshold. The agent is instructed to halt and request human intervention only when its confidence score falls below a set threshold, or when it exhausts its retry budget in the sandbox. The ticket is then routed directly to the human on-call engineer, accompanied by the agent’s execution trace.

The assembled pipeline and its variations

Figure 32.2: The pipeline from top to bottom, with the orchestrator as a lane on the left, a retry loop inside the sandbox and a branch to the on-call engineer. Figure 32.2: The assembled pipeline for the bug-triage case, drawn by this report, with the steps run by code and the steps run by a model in two fills. A deterministic orchestrator sequences the stages. Llama Guard is a small classifier model, not a general-purpose judge.

In practice, this pipeline operates as a sequence of deterministic steps interspersed with cognitive nodes.

When a bug report arrives, Temporal triggers Docling to normalize the text. Temporal then calls the LLM (through Pydantic AI) to classify the ticket using strict JSON schema validation. To reproduce the issue, Temporal provisions an E2B Sandbox. The LLM acts within the sandbox, iterating until the reproduction script works or it gives up. It then retrieves relevant codebase context via pgvector, formulates a diagnosis, and outputs a structured routing payload. Temporal runs this payload through Llama Guard and updates Jira. If the retry loop exceeds three attempts, Temporal halts the process and routes the ticket, with the execution trace, to the on-call engineer.

This structure is highly applicable across a company, but it cannot be a one-size-fits-all stack. It must differ slightly depending on the process:

  • Routine Data Extraction: For a process like extracting normalized data from unstructured vendor emails, the Action capability lever is turned down entirely. The E2B Sandbox is removed because code execution is unnecessary. Verification relies entirely on Structured Outputs, dropping Llama Guard since the risk of dangerous outputs from invoice extraction is zero.
  • Code Review and Lint-Fixing: For a process like automated pull-request review, the Context lever requires a broader view of the repository. Docling might be replaced by direct AST parsing tools, and the Control Loop might be triggered by GitHub Actions rather than Temporal.

This reference architecture is designed for a reasonable balance on the CLEAR dimensions, and that balance is a prediction until it is measured. It maintains a low Cost Per Solved Task by avoiding multi-agent chatter and expensive evaluators. Its Latency is acceptable for asynchronous internal tasks. Its Efficacy should be high because a frontier model is used on narrow, bounded steps. Its Assurance is maintained by the physical isolation of the sandbox. Its Reliability should benefit from the deterministic orchestrator, which prevents the unrecoverable state failures common in purely LLM-driven loops. It is the baseline from which all deviations must be justified.

Delegation boundary

The boundary in this reference instantiation is clear: the system executes the deterministic routing and the bounded cognitive extraction, but the human engineer retains the final authority to actually merge the code fix and resolve the ticket.

This instantiation is one reading of the matrix, for one team and one process. The final chapter sets out the matrix in full.

33. The result: a situational matrix, a frontier that moves, and five gaps

This report set out to separate the agentic methodologies, judge them on evidence, and arrive at one way of choosing among them. This last chapter gathers what the inquiry produced. It recalls the findings part by part, presents the matrix that follows from them, and then states two limits on that result. The frontier moves on every lever, and five questions remain open.

What the report established

Part I set the ground. Agentic AI is an assembly built around a model, not a new kind of model, and the report fixed the vocabulary it would use. Part II went down to the first principle, the loop of tool use, planning and reflection, then built the eight invariant levers on top of it and tested them. They separate real systems, and they do not sort them into species. Part III read the landscape of patterns, frameworks and protocols as settings of those levers, and found most vendor claims unmeasured. Part IV traced the structures of agentic systems back to human organizations. It showed that the hardest problems, such as prompt injection and unfaithful reasoning, come from what the model does not share with a human. Part V drew the conclusion. What decides between methodologies is their economic boundary, and the right setting depends on the situation of whoever pays.

The three hypotheses that carried the reasoning end as follows. The first holds as a design grid and fails as a taxonomy: the levers describe any system, and they class none. The second is half true: the resemblance to human organizations is real, and nothing makes the convergence necessary, since a layer of problems belongs to the model alone. The third stays open: no evidence yet says whether the delegation boundary is a technical limit or a permanent one, and that indecision is itself the finding.

Three dimensions: structure, situation, measure

Those findings add up to a principle with three dimensions.

  1. Structure, the eight levers. The questions any agentic system has to answer: Context, Action capability, Control loop, Decomposition and specialization, Verification and conformance, State persistence, Capability evolution, and Human control.
  2. Situation, the four criteria. What differs from one organization to the next: risk tolerance, process predictability, human attentional budget, and velocity requirement.
  3. Measure, the CLEAR dimensions. The check that a chosen structure fits a given situation: cost, latency, efficacy, assurance and reliability.

The matrix, the fruit of the research

The matrix in Table 33.1 is what the whole inquiry produces. Every column comes from a different part of the report. The question on each row is the lever as Part II defined it. The default, the dial and the cost come from the decision rules of chapter 29, which rest on the evidence of Parts II and III. The last column, what stays with a human, is the delegation boundary that Part IV explained and chapter 26 consolidated.

Table 33.1 The situational matrix

Lever The question it asks Default setting What justifies turning the dial What turning it costs What stays with a human
Context What does the agent know when it decides? Just-in-time retrieval Low process predictability Tokens, and diluted attention Deciding what is worth writing down
Action capability What can it do that cannot be undone? Read-only; a person applies High velocity, with risk tolerance to match Exposure; a guarantee costs utility Defining the perimeter
Control loop Does code or the model decide the next step? Code decides Low process predictability Unbounded, unpredictable runs Deciding how wide the model’s space is
Decomposition and specialization One executor or several, and along which cut? One agent that writes alone Contexts that work against each other Coordination: about 15× the tokens of a chat Choosing the cut and the roles
Verification and conformance How are the product and the process checked? Deterministic checks Low risk tolerance Tokens, latency, false alarms Writing the reference to check against
State persistence What survives the turn, the session, the crash? Session-scoped Tasks that span days or wait for a person Complexity, and data to govern Fixing what is kept and what is deleted
Capability evolution What changes what the agent can do? Static prompts and curated skills A team too small to tune by hand Drift, which has to be evaluated Admitting a capability for good
Human control Where does a person see and intervene? A few gates before consequential actions Volume beyond what people can read Errors found after the fact Approving the irreversible, and answering for it

The matrix is used in three moves. The first is to describe the situation honestly on the four criteria, which is harder than it sounds, since most organizations overstate their tolerance for risk until something breaks. The second is to start every lever at its default and turn a dial only where the situation gives a reason, accepting the cost in the next column. The third is to measure the result on the five CLEAR dimensions and to revise. A spreadsheet distributed with this report extends each row with the tools and catalogue layers of chapter 29.

Used this way, the matrix leads to a conclusion that may surprise after two chapters of tool names: the specific tool does not matter. What matters is the ability to describe the situation and to put the right configuration in front of it. An orchestrator chosen today may be obsolete in two years. The need for a control loop held by code, where an error would be costly, will still be there.

One practice cuts across all eight rows and deserves its own mention, compartmentalization. The designs that hold up keep things apart: the reasoning from the execution environment, the agents that read from the one that writes, the place where a skill is tried from the registry it may enter. Chapters 7, 12 and 19 each arrived at a version of it. As processes grow, deciding what must not touch what becomes as important as deciding what each part does.

The frontier is moving on every lever

The defaults in Table 33.1 are dated. They describe what was sensible in 2026, and on every lever the ground has shifted during the period this report covers. Table 33.2 gives one documented example per lever.

Table 33.2 One recent shift on each lever

Lever What moved What it changes
Context In March 2026 two Claude models received a context window of one million tokens at standard pricing (Anthropic) A whole codebase fits in one prompt. The dilution measured in chapter 6 still applies, so fitting is not the same as attending
Action capability In October 2025 Claude Code gained sandboxing at the level of the operating system, isolating both files and network; its maker reports 84% fewer permission prompts in internal use (Anthropic) Containment replaces prompts, the move chapter 7 argued for
Control loop METR measured that the length of tasks agents complete autonomously, at 50% reliability, has doubled about every seven months for six years (METR) The range of tasks where a model can hold the loop keeps widening
Decomposition and specialization In February 2026 Claude Code introduced agent teams, several agents working in parallel, recommended for independent, read-heavy work (Anthropic) Several agents become a product feature, in the read-only form the single-writer principle predicts
Verification and conformance Shopify raised the agreement between its model judges and human raters from near chance to close to the agreement between humans (Shopify) A model can be calibrated as a judge of outputs. Conformance of the process remains untooled
State persistence In July 2025 Temporal announced durable execution for agents built with the OpenAI Agents SDK, generally available since March 2026 (Temporal) Resuming a failed run from where it stopped becomes a standard integration
Capability evolution In October 2025 Anthropic introduced Agent Skills, folders of instructions, scripts and resources that a model loads when needed (Anthropic) Skills become a packaged, shareable unit, which makes the question of who admits them more pressing
Human control In March 2026 Claude Code gained a mode in which a classifier evaluates each action before it runs, “acting as a substitute for a human approver”. Its maker reports that it misses 17% of the overeager actions in a real sample (Anthropic) The gate itself is being automated, with a measured miss rate

Two readings follow from the table. The first is that the levers are the stable part of this report and the settings are the perishable part. Every row of Table 33.2 changes an answer. None changes a question. A new capability still has to be placed on the eight dials, and the placing still depends on the situation.

The second reading is that the levers move together. Two of the examples describe one and the same trade: stronger containment on the Action capability lever is used to justify fewer gates on the Human control lever. A reader who updates one row of the matrix should look at its neighbors.

For a practitioner the consequence is a habit. The matrix has to be rerun as the tools and models change, and its defaults should be treated as positions held for a while.

The human inspiration

Figure 33.1: A designer draws an organization chart while small mannequins take their places in its boxes. Figure 33.1: The designer of an agentic system is drawing an organization chart, an editorial allegory by this report. One of the new workers is already checking another’s work. The comparison with human organizations is the one made in arXiv 2512.07665.

One finding holds across every part of the report. These systems draw on human organizations, and they do so heavily. Designing an agentic system means rebuilding, in small, problems that factories and companies have faced for a long time. The debates of the field are the debates of organization theory: efficiency against agility on a production line, the separation of powers between those who act and those who verify, the chain along which a decision travels. The designer of an agentic system is also drawing an organization chart, for workers of a kind that no chart was drawn for before.

The gaps this methodology accepts

The methodology has limits, and they are stated here so that no reader has to discover them.

1. Trajectory conformance is not tooled. The CLEAR dimensions measure what an agent produced. Nothing in the corpus checks, while it runs, that an agent followed the procedure it was given.

2. Prompt injection remains unresolved. The methodology relies on containment because the underlying flaw, a model’s inability to tell an instruction from data, has no reliable fix. Every published defense of the detecting kind fell to an attacker who adapted.

3. No comparison at constant model and budget. Until two architectures are compared with the same model and the same token budget, the benefit of any structure remains entangled with what it spent.

4. The delegation boundary is undecided. Whether what an agent cannot carry today, such as accountability, long-term incentives and reputation, marks a technical limit or a permanent one remains open, as chapter 25 concluded.

5. The methodology is untested. The matrix, the two profiles and the reference instantiation are syntheses of the evidence gathered here. None has been run in production by the author, and the CLEAR dimensions have not been applied to them.

These five gaps mark where the evidence stops. They are also the list of what would have to be measured for the matrix to become more than a reasoned proposal. Until then it should be used as one: eight questions, a way of answering them for a given situation, and an instrument for finding out whether the answer was right.

Sources cited on this page (18)

Downloads