Chapter 10: Composing patterns: From map to terrain
Introduces pattern composition through an identifier handoff failure and the need to preserve continuity across consequential interfaces.
After this chapter you will be able to
- Identifier handoff continuity. Explain how the salary-template task failed despite valid tool calls and how the team preserved the original identifier.
- Program enforced interface contracts. Explain how natural-language agent decisions coexist with program-enforced contracts at consequential interfaces.
- Map and task comparison. Describe how the pattern matrix, task model, and comparison contribute to a composition decision.
- Baseline-first pattern selection. Explain how a task contract and a baseline guide the decision to consult the pattern catalog.
- End-to-end baseline test. Describe how to choose and test the smallest plausible baseline against the task contract, and what to do with the result.
- Failure focused cognitive diagnosis. Explain how to use the seven cognitive functions to diagnose an observed failure rather than compile a feature wish list.
- Local dependency shape selection. Explain how ordered, mutually exclusive, and independent work suggest different topologies, and why the business label alone does not decide among them.
- Pattern Map Candidate Selection. Explain how to generate pattern candidates by combining the diagnosed cognitive function with the dependency shape.
- Testable Architecture Hypotheses. Describe what to record for each candidate and explain why its architecture hypothesis must make the claimed mechanism and potentially refuting evidence visible.
- Consequential seam specification. Describe what to specify at handoffs where ambiguity could invalidate the task, tracing the path from the failed baseline through the proposed patterns.
- Comparable controlled composition experiment. Describe how to test the proposed composition against the baseline, including the three named forms of fit and the safeguards required by the experiment's risks.
- Provisional acceptance conditions. State the three conditions for provisionally accepting a proposal.
- Smallest responsible layer. Explain how to respond when a proposal fails, using the section's examples of contract, handoff, and latency problems.
- Acceptance reopening conditions. Explain what provisional acceptance is bound to and when the decision must be reopened.
- Pattern map and terrain. Distinguish what the pattern map can suggest from what the task terrain contributes. Explain why a map coordinate alone cannot determine the right architecture.
- Context driven pattern selection. Explain how a team uses the problem context, tradeoffs, and pattern questions to select and test a composition. Illustrate with a question prompted by one named pattern.
- Pattern map candidate inference. Explain how a bounded task need and a pattern coordinate suggest a candidate architecture, using one of the section’s examples. Describe why the candidate becomes a hypothesis to test rather than an automatic selection.
- Task terrain and interfaces. Explain what task terrain adds to a user story and why the same patterns may need different interfaces in different organizations.
- Task spine and seams. Describe the task spine and continuity lines, and identify where a consequential seam can occur.
- Evidence loss across stages. Explain how compaction can leave a critic unable to catch an error and how the example restores access to the missing evidence.
- Task modeling before patterns. Describe how to frame a complete task and reconstruct the current process before selecting patterns.
- Bounded task completion contract. Explain how a Task Completion Contract distinguishes a bounded task from a broad agent goal and records what completion permits and requires before architecture choices begin.
- Observable outcome beyond output. Explain why a completion contract must go beyond a well-formed answer or tool receipt, using an example of checking the actual outcome.
- Existing Task Spine. Describe how to draw the existing task and trace its continuity lines after writing the contract.
- Task and State Continuity. Distinguish the facts preserved by Task continuity from those preserved by State continuity.
- Authority and Evidence Continuity. Distinguish what Authority continuity preserves from what Evidence continuity connects.
- First deviation diagnosis. Explain how to locate the first observable state that no longer supports the Task Completion Contract and why repairing only the final symptom may miss the broken handoff.
- State and authority contracts. Explain what contracts must establish when a handoff involves shared state or authority.
- Effects and acceptance boundaries. Explain what a contract needs when an external effect is possible or a result will close the task.
- Bounded exploratory flexibility. Explain why exploration can remain flexible inside an appropriate boundary.
- Baseline before explicit composition. Explain when a general-purpose agent can replace a more elaborate composition and when an explicit pattern should be added.
- Executable agent interfaces. Describe the interfaces a general-purpose agent still uses and distinguish the model's role from the platform's role in command execution.
- Context and environmental boundaries. Explain why larger context and stronger agents do not remove the need for environmental controls, using an example from the section.
- Selection card and receipt. Distinguish what the pattern selection card records from what the evaluation receipt records, and explain why they are separate.
- Evidence for composition size. Explain how comparison and evidence govern admission and removal of mechanisms in a composition.
- Fixed stages and tool choice. Describe the fixed workflow order in the salary-import exercise and where the model may make a choice.
- Salary task completion contract. Describe what counts as completing the salary-template task and why a returned import call is not enough.
- Receipt identifier state binding. Explain the baseline’s first reported deviation and the immediate repair.
- Candidate composition and baseline. Explain why Tool Dispatch plus Guardrail Sandwich is proposed and when the simpler direct-binding handler should be retained.
- Pattern fit for sequences. Distinguish the fixed match/import/readback sequence from situations that justify Plan-and-Execute or Prompt Chaining.
- Reusable logic and domain adapters. Distinguish reusable action-control logic from the salary-template-specific services and responsibilities that adapters must supply.
- Trusted import admission path. Trace how trusted match values reach the guarded import and explain what admission checks.
- Independent acceptance and closure. Explain how the salary-template import is verified and when the task can be closed.
- Commit recovery and replay. Explain the supplied commit store’s production limitation and how a matching replay behaves when a prior commit remains reserved.
- Controlled workload comparison. Describe how to compare the original agent, direct-binding handler, and dispatch/guard composition fairly.
- Completion and safety gates. Explain what to record and what safety and completion requirements the comparison must enforce.
- Acceptance and reopening decision. Explain when to accept the composition card, choose an alternative, and reopen the choice.
- Client-facing publication acceptance. Explain why GIS publication must be verified through the client-facing service, and describe the checks and evidence used for acceptance.
- Synthetic workload distribution mismatch. Explain why the synthetic training set did not represent real-user requests and why more examples from the same templates would not fix the mismatch.
- Representative router acceptance gate. Describe how the team evaluated the router independently of synthetic generation and what behaviors it checked.
- Tool Visibility and Execution Authorization. Explain the authorization gap in the DeerFlow case and how applying one policy source at two seams addresses it.
- Task Contract and Terrain. Describe how the Task Completion Contract and Task Terrain Graph represent the task and its current workflow.
- Selection and Evaluation Evidence. Distinguish the Pattern Selection Card from the Evaluation Receipt in the composition record.
- Reopening and Architecture Simplification. Explain how reopen triggers and preserved evidence support revisiting and potentially simplifying a composition.
- Authority across module boundaries. Explain why having all seven cognitive modules does not prove correct composition, and describe how the Argus self-test checks task authority at real boundaries.
- Completion and memory gates. Explain how missing reflection evidence affects completion and why the memory-write decision is separate from task completion.
What it builds on
- The execution topology axis (chapter 2) · The execution topology axis for comparing pattern choices.
- The complete pattern map (chapter 2) · The canonical pattern map
- Pattern: Semantic compaction (chapter 3) · Semantic Compaction as a way to compress context.
- Pattern: Generator-Critic (chapter 7) · Generator-Critic as a review pattern.
- The pattern selection card (chapter 2) · The pattern selection card as a way to record pattern choices.
- Pattern: Tool Dispatch (chapter 6) · Tool Dispatch as an action pattern
- Pattern: Guardrail Sandwich (chapter 6) · Guardrail Sandwich as an action pattern
- Pattern: Prompt Chaining (chapter 6) · Prompt Chaining and checked intermediate artifacts
Section by section
Introduction
Introduces pattern composition through an identifier handoff failure and the need to preserve continuity across consequential interfaces.
- Identifier handoff continuity: Explain how the salary-template task failed despite valid tool calls and how the team preserved the original identifier.
Why it matters: A correctly formatted tool argument can still be the wrong value. - Program enforced interface contracts: Explain how natural-language agent decisions coexist with program-enforced contracts at consequential interfaces.
Why it matters: Flexible decisions and reliable boundaries can coexist in the same agent. - Map and task comparison: Describe how the pattern matrix, task model, and comparison contribute to a composition decision.
Why it matters: A pattern’s place on a map is a starting point, not proof that a composition should be kept.
Key terms: identifier, tool receipt, runtime binding, program-enforced contracts, shared state, delegated authority, external effect, pattern matrix, task model, Task
10.1 The evidence-driven six-step method
This section introduces a baseline-first method for selecting patterns and defines task contracts and seams.
- Baseline-first pattern selection: Explain how a task contract and a baseline guide the decision to consult the pattern catalog.
Why it matters: This keeps pattern selection tied to a demonstrated need rather than adding patterns by default. - Seam as dependent handoff: Describe what a seam is in a composed agent system.
Why it matters: Naming seams helps identify where components depend on one another.
Key terms: task contract, permitted effects, observable completion conditions, baseline, catalog, deficit, seam, handoff, state, result
10.1.1 Step 1: Bound completion
10.1.2 Step 2: Run the smallest end-to-end baseline
Establish and test the simplest plausible end-to-end baseline, and revisit it as capabilities improve.
- End-to-end baseline test: Describe how to choose and test the smallest plausible baseline against the task contract, and what to do with the result.
Why it matters: A simple solution that meets the actual acceptance criteria is a successful architecture decision. - Baseline renewal after improvements: Explain why improvements in models or their supporting capabilities can justify replacing a more elaborate composition with a new baseline.
Why it matters: Reconsidering the baseline can prevent an architecture from retaining complexity it no longer needs.
Key terms: baseline, contract, real acceptance point, first deviation, required gate, deficit, composition, native harness
10.1.3 Step 3: Diagnose the binding deficit
This section diagnoses observed agent failures using cognitive functions and matches the failing work’s dependency shape to a possible execution topology.
- Failure focused cognitive diagnosis: Explain how to use the seven cognitive functions to diagnose an observed failure rather than compile a feature wish list.
Why it matters: Starting from observed failure focuses pattern selection on a real deficit. - Local dependency shape selection: Explain how ordered, mutually exclusive, and independent work suggest different topologies, and why the business label alone does not decide among them.
Why it matters: Different work within the same business domain can require different execution structures. - Feedback and coordination shapes: Describe which topologies are suggested by repeated feedback testing, recursive delegation, and centrally coordinated dependencies.
Why it matters: These distinctions help match the topology to how work repeats or is coordinated.
Key terms: cognitive functions, diagnostic questions, observed failure, dependency shape, Chain, Route, Parallel, topology, Loop, Hierarchy
10.1.4 Step 4: Generate a small candidate set from the map
Generate a small set of pattern candidates from the diagnosed task and express each as a testable architecture hypothesis.
- Pattern Map Candidate Selection: Explain how to generate pattern candidates by combining the diagnosed cognitive function with the dependency shape.
Why it matters: This turns a diagnosed deficit into a manageable set of architecture options. - Testable Architecture Hypotheses: Describe what to record for each candidate and explain why its architecture hypothesis must make the claimed mechanism and potentially refuting evidence visible.
Why it matters: A testable hypothesis makes the reasoning behind a pattern choice inspectable rather than relying on a vague promise.
Key terms: cognitive function, dependency shape, canonical matrix, candidate, architecture hypothesis, preconditions, expected effect, workload-specific parameters, credible alternative, claimed mechanism
10.1.5 Step 5: Specify consequential seams and define the experiment
This section explains how to specify consequential handoffs and design a comparable, controlled test of a proposed pattern composition.
- Consequential seam specification: Describe what to specify at handoffs where ambiguity could invalidate the task, tracing the path from the failed baseline through the proposed patterns.
Why it matters: Explicit seams make consequential handoffs less likely to undermine the task. - Comparable controlled composition experiment: Describe how to test the proposed composition against the baseline, including the three named forms of fit and the safeguards required by the experiment's risks.
Why it matters: A comparable test with appropriate safeguards can expose failures without treating a risky experiment as consequence-free.
Key terms: seam, handoff, authority, permitted effects, recovery, acceptance, task-pattern fit, pattern-pattern fit, architecture-workload fit, failure injection
10.1.6 Step 6: Compare, decide, and reopen
Compare a proposal against the baseline, revise failures at the responsible layer, and reopen provisional acceptance when tested conditions change.
- Provisional acceptance conditions: State the three conditions for provisionally accepting a proposal.
Why it matters: A proposal must solve a demonstrated problem without creating an unacceptable new one. - Smallest responsible layer: Explain how to respond when a proposal fails, using the section's examples of contract, handoff, and latency problems.
Why it matters: A targeted repair addresses the failure without unnecessarily weakening the task's completion requirements. - Acceptance reopening conditions: Explain what provisional acceptance is bound to and when the decision must be reopened.
Why it matters: Evidence for a proposal applies to the conditions under which it was tested, not automatically to changed conditions.
Key terms: baseline, required gate, proposal, regression, task-contract error, stale-state seam, handoff, latency, completion gate, acceptance
10.2 From pattern map to task terrain
This section explains how the pattern map suggests candidates while task-specific context and evidence guide their selection and composition.
- Pattern map and terrain: Distinguish what the pattern map can suggest from what the task terrain contributes. Explain why a map coordinate alone cannot determine the right architecture.
Why it matters: The distinction keeps a useful catalog from being mistaken for a complete architecture decision. - Context driven pattern selection: Explain how a team uses the problem context, tradeoffs, and pattern questions to select and test a composition. Illustrate with a question prompted by one named pattern.
Why it matters: Making context and assumptions explicit helps a team test a pattern choice rather than adopting it by name alone.
Key terms: pattern map, task terrain, cognitive functions, execution topologies, pattern language, forces and tradeoffs, preconditions, task workflow, composition
10.2.1 What the map can suggest
This section shows how pattern-map coordinates suggest candidates for a specific task need, which become architecture hypotheses to test.
- Pattern map candidate inference: Explain how a bounded task need and a pattern coordinate suggest a candidate architecture, using one of the section’s examples. Describe why the candidate becomes a hypothesis to test rather than an automatic selection.
Why it matters: The map helps narrow the choices without treating a suggested pattern as a proven solution.
Key terms: pattern coordinate, architecture hypothesis, mechanism, preconditions
10.2.2 What the terrain adds
This section explains how a task’s operating terrain shapes pattern interfaces and why evidence must remain available across seams.
- Task terrain and interfaces: Explain what task terrain adds to a user story and why the same patterns may need different interfaces in different organizations.
Why it matters: The same pattern choices can work differently when the surrounding workflow changes. - Task spine and seams: Describe the task spine and continuity lines, and identify where a consequential seam can occur.
Why it matters: Tracing what must continue across a workflow helps reveal boundaries that are easy to overlook. - Evidence loss across stages: Explain how compaction can leave a critic unable to catch an error and how the example restores access to the missing evidence.
Why it matters: A review stage cannot reliably challenge a claim using evidence that was lost before it arrived.
Key terms: task terrain, user story, interfaces, task spine, seam, Task, State, Authority, Evidence, Semantic Compaction
10.3 Model the complete task before selecting patterns
This section explains how to model a complete task and its current outcome before choosing patterns.
- Task modeling before patterns: Describe how to frame a complete task and reconstruct the current process before selecting patterns.
Why it matters: Starting with the complete task helps you avoid choosing patterns before understanding the outcome and the current process.
Key terms: pattern shopping, starting state, intended effect, forbidden effects, acceptance evidence
10.3.1 The Task Completion Contract
This section defines a Task Completion Contract and shows why completion must be judged against the bounded task and its observable effects, not merely a well-formed output or a ready application.
- Bounded task completion contract: Explain how a Task Completion Contract distinguishes a bounded task from a broad agent goal and records what completion permits and requires before architecture choices begin.
Why it matters: Bounding completion gives architecture decisions a concrete task to serve. - Observable outcome beyond output: Explain why a completion contract must go beyond a well-formed answer or tool receipt, using an example of checking the actual outcome.
Why it matters: A plausible response or successful call can hide a task that has not actually been completed. - Application and review completion: Distinguish completion of the proposal-review application from completion of a proposal review, including how the application handles missing evidence.
Why it matters: A system being ready to use does not mean the human task it supports is finished.
Key terms: task, goal, Task Completion Contract, permitted effects, observable completion conditions, output schema, authoritative business readback, tool receipt, completion contracts, source evidence
10.3.2 Draw the task spine and four continuity lines
This section shows how to map an existing task and trace four distinct continuity lines through it.
- Existing Task Spine: Describe how to draw the existing task and trace its continuity lines after writing the contract.
Why it matters: The current task provides the baseline for seeing what must remain continuous. - Task and State Continuity: Distinguish the facts preserved by Task continuity from those preserved by State continuity.
Why it matters: These lines separate continuity of the work itself from continuity of the facts it uses. - Authority and Evidence Continuity: Distinguish what Authority continuity preserves from what Evidence continuity connects.
Why it matters: These lines distinguish permission to act from the evidence needed to reconstruct the result. - Shared Artifacts Across Lines: Explain how one artifact can participate in several continuity lines, using a plan as an example.
Why it matters: Tracing separate questions does not require inventing a separate artifact for each line.
Key terms: task spine, Task, State, Authority, Evidence, acceptance point, Task continuity, State continuity, run identity, permitted mutation
10.3.3 Locate the first deviation
This section explains how to locate the first observable deviation from a task completion contract rather than treating a downstream error as the root problem.
- First deviation diagnosis: Explain how to locate the first observable state that no longer supports the Task Completion Contract and why repairing only the final symptom may miss the broken handoff.
Why it matters: Finding the earliest deviation helps you repair the actual handoff instead of merely masking its consequences.
Key terms: first deviation, observable state, Task Completion Contract, broken handoff
10.4 Make consequential interfaces explicit
This section explains where consequential handoffs need explicit contracts and where agents can retain flexibility within bounded workspaces.
- State and authority contracts: Explain what contracts must establish when a handoff involves shared state or authority.
Why it matters: These contracts keep state and authority meaningful across component boundaries. - Effects and acceptance boundaries: Explain what a contract needs when an external effect is possible or a result will close the task.
Why it matters: A proposed action and its claimed success are not enough to establish a completed external result. - Contract representation and selection: Describe how explicit interface contracts can be represented and how their fields are selected.
Why it matters: The contract should fit the handoff rather than force every interface into one format or field list. - Bounded exploratory flexibility: Explain why exploration can remain flexible inside an appropriate boundary.
Why it matters: Constraining consequential actions need not eliminate the adaptability agents are chosen for.
Key terms: shared or durable state, authority, principal, mutation rule, external side effect, normalized intent, preconditions, idempotency, recovery boundary, acceptance owner
10.5 Do general-purpose agents make composition obsolete?
This section explains when general-purpose agents can replace custom pattern compositions and why executable interfaces and environmental controls remain necessary.
- Baseline before explicit composition: Explain when a general-purpose agent can replace a more elaborate composition and when an explicit pattern should be added.
Why it matters: This keeps the architecture as simple as the observed task performance permits. - Executable agent interfaces: Describe the interfaces a general-purpose agent still uses and distinguish the model's role from the platform's role in command execution.
Why it matters: Even a flexible agent depends on an execution environment with concrete interfaces and rules. - Context and environmental boundaries: Explain why larger context and stronger agents do not remove the need for environmental controls, using an example from the section.
Why it matters: More context and model capability do not by themselves enforce consequential boundaries or establish outcomes.
Key terms: general-purpose agents, baseline, native primitive, explicit pattern, reproducible deficit, Skills, command line, graphical controls, platform, bounded results
10.6 The pattern selection card and evaluation receipt
This section separates architecture proposals from evaluation results and explains how evidence determines whether a pattern composition is accepted or simplified.
- Selection card and receipt: Distinguish what the pattern selection card records from what the evaluation receipt records, and explain why they are separate.
Why it matters: Separating the proposal from its test result makes the architecture decision easier to evaluate honestly. - Evidence for composition size: Explain how comparison and evidence govern admission and removal of mechanisms in a composition.
Why it matters: A composition earns its complexity through evidence rather than a fixed pattern count or an attractive proposal. - Executable architecture evaluation: Explain why architecture candidates need executable evaluation rather than certification by a pattern catalog.
Why it matters: Pattern names alone cannot establish that an agent architecture works under its real constraints.
Key terms: pattern selection card, ASSESS, ROUTE, SELECT, evaluation receipt, candidate generation, admission, comparison, composition, seams
10.7 Selecting and connecting patterns for a salary-template task
The section frames a salary-import design exercise around an identifier failure and a workflow with fixed stages but flexible tool choices.
- Fixed stages and tool choice: Describe the fixed workflow order in the salary-import exercise and where the model may make a choice.
Why it matters: The distinction separates the workflow's fixed sequence from the model's flexibility within a stage.
Key terms: matching, import, readback, tools
10.7.1 From observed failure to a candidate composition
This section diagnoses a salary-template task’s observed failure and selects a proportionate candidate composition for testing.
- Salary task completion contract: Describe what counts as completing the salary-template task and why a returned import call is not enough.
Why it matters: A tool call returning does not by itself establish that the intended business result exists. - Receipt identifier state binding: Explain the baseline’s first reported deviation and the immediate repair.
Why it matters: The right sequence of tools can still fail if a value changes between calls. - Candidate composition and baseline: Explain why Tool Dispatch plus Guardrail Sandwich is proposed and when the simpler direct-binding handler should be retained.
Why it matters: A composition should address demonstrated service needs without replacing a simpler solution that already meets them. - Pattern fit for sequences: Distinguish the fixed match/import/readback sequence from situations that justify Plan-and-Execute or Prompt Chaining.
Why it matters: Serial calls alone are not evidence that a more elaborate orchestration or handoff is needed. - Policy driven approval gate: Explain when this service should add an Approval Gate and why a precondition check cannot replace required human approval.
Why it matters: A technical precondition cannot override a policy requirement for human approval.
Key terms: business query, active principal, import permission, template_id, matching receipt, runtime state binding, Tool Dispatch, Guardrail Sandwich, direct binding, admission
10.7.2 Reuse the mechanisms and supply the adapters
This section adapts reusable action-control mechanisms to a salary-template import and traces their admission, verification, and recovery boundaries.
- Reusable logic and domain adapters: Distinguish reusable action-control logic from the salary-template-specific services and responsibilities that adapters must supply.
Why it matters: Reusing the control structure does not eliminate the need to implement the task’s own domain boundaries. - Trusted import admission path: Trace how trusted match values reach the guarded import and explain what admission checks.
Why it matters: This path shows where trusted values enter the import and what the admission check can actually guarantee. - Independent acceptance and closure: Explain how the salary-template import is verified and when the task can be closed.
Why it matters: An import call is not enough to establish that the task finished successfully. - Commit recovery and replay: Explain the supplied commit store’s production limitation and how a matching replay behaves when a prior commit remains reserved.
Why it matters: Recovery must account for an uncertain prior effect without blindly performing it again.
Key terms: control logic, domain adapter, DispatchContext, matching service, tenant policy, match receipt, ToolIntent, ArgusAction.execute(), dispatch(), admit()
10.7.3 Compare on the same workload before accepting
This section defines a controlled comparison and evidence-based acceptance decision for the salary-import composition.
- Controlled workload comparison: Describe how to compare the original agent, direct-binding handler, and dispatch/guard composition fairly.
Why it matters: A controlled comparison makes differences between the alternatives more meaningful. - Completion and safety gates: Explain what to record and what safety and completion requirements the comparison must enforce.
Why it matters: The comparison must distinguish a reported tool success from a safely completed business task. - Benefit attribution and test scope: Distinguish the evidence supplied by a direct-binding-only ablation and the chapter 6 local-fake tests.
Why it matters: These distinctions prevent reusable test results or a combined improvement from being credited to the wrong cause. - Acceptance and reopening decision: Explain when to accept the composition card, choose an alternative, and reopen the choice.
Why it matters: A composition earns acceptance through evidence and remains open to revision when conditions change.
Key terms: versioned cases, test tenant, run-to-run variation, externally accepted completions, business readback, quality and latency budgets, direct-binding-only ablation, local fakes, admission and execution checks, failing gate
10.8 Three field pressure tests
Introduces three field cases and their evidence for pressure-testing the composition method.
10.8.1 GIS publication: An internal receipt is not the delivered result
This section uses GIS publication failures to show why acceptance must verify the client-facing result rather than rely on an internal success receipt.
- Client-facing publication acceptance: Explain why GIS publication must be verified through the client-facing service, and describe the checks and evidence used for acceptance.
Why it matters: A successful internal call or HTTP status alone does not establish that a client can use the published service.
Key terms: acceptance boundary, GetMap, GetTile, task receipt, client-facing path
10.8.2 Learned routing: A valid training set can still misrepresent the workload
This case shows why a learned router needs evaluation on representative user requests despite valid synthetic training data and converged loss.
- Synthetic workload distribution mismatch: Explain why the synthetic training set did not represent real-user requests and why more examples from the same templates would not fix the mismatch.
Why it matters: Valid training examples can still teach shortcuts that fail on the workload the router will actually face. - Representative router acceptance gate: Describe how the team evaluated the router independently of synthetic generation and what behaviors it checked.
Why it matters: The first routing decision supplies later actions, so its correctness must be tested against the intended workload. - Router evaluation receipt: State what the Evaluation Receipt should record for this router.
Why it matters: The receipt preserves the evidence and decision associated with a particular router evaluation. - Routing continuity and authority: Distinguish the task, state, evidence, and authority concerns at the routing seam.
Why it matters: A correct routing decision does not by itself establish that the selected capability is authorized.
Key terms: structural uniformity, positional shortcuts, class balance, distribution problems, route accuracy, entity-parameter fidelity, clarification and rejection calibration, held-out evidence, Evaluation Receipt, held-out workload boundary
10.8.3 DeerFlow guardrails: Authorize tool visibility and execution
The DeerFlow case shows why tool visibility and execution must be authorized at separate seams using the same policy source.
- Tool Visibility and Execution Authorization: Explain the authorization gap in the DeerFlow case and how applying one policy source at two seams addresses it.
Why it matters: Blocking a call alone does not ensure the model sees only tools the principal is authorized to use.
Key terms: authorization provider, tool assembly, deferred discovery, runtime guard
10.9 The composition record
The section describes the linked artifacts in a composition record and how they keep architecture decisions connected to operating evidence.
- Task Contract and Terrain: Describe how the Task Completion Contract and Task Terrain Graph represent the task and its current workflow.
Why it matters: These artifacts connect the definition of completion to the workflow being designed. - Selection and Evaluation Evidence: Distinguish the Pattern Selection Card from the Evaluation Receipt in the composition record.
Why it matters: Keeping the candidate and its evaluation together makes the architecture decision traceable. - Reopening and Architecture Simplification: Explain how reopen triggers and preserved evidence support revisiting and potentially simplifying a composition.
Why it matters: A composition can evolve when conditions change without losing the evidence behind its decisions.
Key terms: Task Completion Contract, Task Terrain Graph, Task, State, Authority, Evidence, Pattern Selection Card, Evaluation Receipt, baseline deficit, consequential seams
10.10 Argus as a composition self-test
This section uses Argus to test whether composed modules respect authority, require evidence for completion, and write durable memory only after external acceptance.
- Authority across module boundaries: Explain why having all seven cognitive modules does not prove correct composition, and describe how the Argus self-test checks task authority at real boundaries.
Why it matters: A system can appear governed while its real operations bypass the intended authority boundary. - Completion and memory gates: Explain how missing reflection evidence affects completion and why the memory-write decision is separate from task completion.
Why it matters: These gates prevent an unsupported success claim from becoming durable memory. - Boundary tests and records: Describe how to extend the offline tests before integrating real modules and what to do with the results.
Why it matters: Boundary tests expose integration failures that isolated module tests can miss and provide evidence for the decision record.
Key terms: authority, authorized_reader(), plan version, write set, completion gate, reflection evidence, external acceptance, durable memory, memory-write decision, boundary tests
10.11 Summary
10.12 References
This section lists sources referenced in the chapter, including case reports, research, and technical materials.
Where this is used later
- Failure two: A valid argument loses its origin (chapter 11) · A later case examines an argument that loses its origin.
- Taking the patterns into your own work (chapter 11) · The evidence-driven method for moving from a bounded task and baseline to an architectural decision.
- A zero-pattern control: When evidence says stop (chapter 11) · The zero-pattern control illustrates stopping when the baseline succeeds.
- Layer 2: Task-pattern fit (chapter 11) · Generating candidate compositions
- Case 3: Operating evidence reopens the architecture (chapter 11) · Comparing and deciding on a design while leaving room to reopen the decision.
- Two operating mismatches changed the design (chapter 11) · Compare candidates before making an architecture decision.
- Decision and reopen condition (chapter 11) · Connects the architecture decision to a condition for reopening it.
- Bound the completed task (chapter 11) · A case begins by bounding the completed task.
Concepts explained in this chapter
- evaluation receiptAn evaluation receipt is a record of a model's training and generator versions, held-out workload, evaluation results, and release decision.
- contractAn agreement specifying conditions that a task, state, authority, or evidence must satisfy.
- dispatchingThe assignment of a request or unit of work to a processing path or handler based on its properties.
- agentAn autonomous software system that performs tasks by perceiving information, reasoning, and taking actions.
- agent skillA packaged agent capability that specifies how to perform a class of tasks, including relevant tools and workflow guidance.
- guardrail sandwichAn execution pattern that places a state-changing action between trusted pre-check and post-check controls, with a controlled executor in between.
- admissionTool admission is a check that a proposed tool operation remains authorized and appropriate given current authority, provenance, and state freshness.
- Pattern Selection CardA book-specific aid for choosing among recurring agent execution topologies.
- approval gateA control point that determines whether an operation may proceed autonomously or requires human authorization.
- plan-and-executeAn agent pattern in which planning precedes execution of the planned steps.
- prompt chainA workflow pattern that divides a known sequence into narrow stages, with each stage producing an artifact that passes a gate before the next stage proceeds.
- evidenceInformation that supports or substantiates a claim or decision.
- source of truthA source of truth is the authoritative source for a particular piece of information.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
