Module 5: Start Here

Overview

Module 4 chose the components. This module asks how much latitude they get.

When does a system need an agent rather than a pipeline, and what does that decision cost?

Agency is the point where an AI system stops being a feature and becomes a distributed system with a non-deterministic scheduler. The system no longer just produces text you check — it decides what to do next, calls things, and changes state. In the running case it can reschedule a job, issue a credit and reset a device, which means the blast radius has a currency symbol in front of it.

The honest finding of this module, stated up front: most problems do not need an agent, and the ones that do need one need it bounded far more tightly than the demos suggest.

How the module is built

Two sections. The first decides whether to grant agency and constrains it. The second handles what happens once you have — coordination, context, and the evidence you need when someone asks why it did that.

graph TD
  subgraph S1["Section 1 — Deciding on agency"]
    A["1 · The autonomy<br/>spectrum"]
    B["2 · Should this<br/>be an agent?"]
    C["3 · Agent patterns"]
    D["4 · Bounding<br/>the loop"]
    E["5 · The tool<br/>surface"]
    F["6 · The action<br/>boundary"]
    A --> B --> C --> D --> E --> F
  end
  subgraph S2["Section 2 — Coordination, context and evidence"]
    G["7 · Multi-agent<br/>topologies"]
    H["8 · The coordination<br/>cost"]
    I["9 · Managing<br/>context"]
    J["10 · MCP as<br/>a seam"]
    K["11 · Observability<br/>for agents"]
    L["12 · The human<br/>handoff"]
    G --> H --> I --> J --> K --> L
  end
  F ==> G
  L ==> M(["Workbook — Exercise 5"])

  classDef s1 fill:#5B8FB9,stroke:#4A7A9E,stroke-width:2px,color:#ffffff
  classDef s2 fill:#E8A33D,stroke:#C4832A,stroke-width:2px,color:#ffffff
  classDef cap fill:#D9695B,stroke:#B4483A,stroke-width:2px,color:#ffffff
  class A,B,C,D,E,F s1
  class G,H,I,J,K,L s2
  class M cap

The module’s path. Section 1 is mostly about saying no, or saying yes with constraints. Section 2 is about living with the yes.

Section 1 — Deciding on agency

How much latitude exists → should you grant it → which shape → how tightly bounded → what it can reach → what it may actually do.

1. The autonomy spectrumFrom a single call to an autonomous agent, and what each step transfers to the model.

2. Should this be an agent?Four criteria, and the technique for genuinely considering the pipeline.

3. Agent patternsReAct, Plan-and-Solve, Reflexion — matched to task shape, with their failure modes.

4. Bounding the loopFour kinds of bound, and why you need both advisory and enforced.

5. The tool surfaceWhy the shape of a tool call determines what you can do about it.

6. The action boundaryEvery argument the model supplies is untrusted input. Enforce accordingly.

Section 2 — Coordination, context and evidence

7. Multi-agent topologiesSupervisor, peer and critic arrangements, and when more than one genuinely wins.

8. The coordination costThe bill that usually makes a single agent the right answer.

9. Managing contextPrune, summarise or externalise — three mechanisms, three different losses.

10. MCP as a seamWhat a protocol standardises, and the authorisation it does not.

11. Observability for agentsAnswering 'why did it issue that credit' after the fact.

12. The human handoffWhat the person receives, not just when the handoff triggers.

How to work this module

About six hours:

1. Read the twelve topics — about 3.5 hours. Topics 5 and 6 are the ones that change designs; they are also the least discussed anywhere else.

2. Optional — Workbook exercise 5 — about 2.5 hours. Five artifacts, and one of them classifies every action the system can take.

In the workbook

Five artifacts for Lintel:

• An agent design stating why an agent rather than a pipeline
• The tool and action boundary — what may happen unaided, what needs confirmation, what is forbidden
• An MCP-based tool integration design
• A human handoff protocol written for the people who will receive the handoffs
• An observability plan covering tracing and per-interaction cost attribution

Before you start

Module 1’s guardrails topic introduced blast-radius tiers. This module turns them into enforcement points. If you skipped it, read it first — the four tiers are assumed.

Microservice mechanics are not re-taught. Idempotency, retries, circuit breakers and distributed tracing are prerequisite knowledge. What is new is that the thing calling your services is non-deterministic, which changes what those mechanisms have to protect against.

Check your understanding

Answer now, revisit at the end.

1. Think of a workflow you would describe as “an agent”. Could a fixed sequence of three steps do most of it?
2. What is the most consequential action you would let software take without a human looking? Why that line?
3. If a system took a wrong action last Tuesday, what would you need to have recorded in order to explain it today?

→ Start with The autonomy spectrum.