Every figure in the book — 75 in all — gathered here in reading order, each with its full caption. A quick way to review the book's visuals in one place; every figure links back to where it appears in the text. The chapter figures come first; the appendix pattern pages follow in a lighter schematic style. (See also the List of Figures and Tables for tables, and a scannable index of short captions.)
Chapter figures
The book-proper figures, hand-drawn to the house palette.
Figure 0.1-1. The whole method on one page: a coding agent — a reasoning engine paired with a printer — generates code through a fleet, and the two theses fill a governed environment. That environment is bootstrapped up front from known constraints, then grown by governance conversion into trustworthy software.
Figure 0.3-1. The MAGE method in one picture. A cheap agent fleet, left ungoverned, drifts into churn as its work outgrows the context window. Governed through the Modeling Thesis and the Alignment Thesis, it converges on trustworthy software at velocity.
Figure 0.3-2. Three process models for agentic software engineering. Velocity-centric rings job titles around an implicit quality mechanism; oversight-centric straddles a human over each bounded piece, whose attention does not scale. Governance-centric is the synthesis — agents work inside enforced mechanisms set up once, so reliability scales.
Figure 0.4-1. The book in one map. Part 1 sets the frame and the two theses; Part 2 works the Alignment Thesis into fleet controls, Part 3 the Modeling Thesis into models. Both feed Part 4 (the method) and Part 5 (the DocAble case study), then the closing implications and appendix.
Figure 1.1-1.The Task-Mode Heuristic. Specify a task's input/output behavior, then split on size and difficulty: a simple no-reasoning task goes to one-shot scripting, a hard or reasoning-heavy one to supervised autonomy. If unsure, try to one-shot it, but switch paths rather than throw good tokens after bad.
Figure 1.2-1. DocAble in one picture. The working half takes the document in — a front door, a dispatcher that splits it into chunks, a remediation core that repairs each. The trust half is why the result can be believed: a checker, a fidelity validator, a provenance stamp, and nothing ships unchecked.
Figure 1.3-1.The Printer Loop. The loop that produces: a goal becomes a model, the agent builds, evidence meets judgment, and the model sharpens each pass.
Figure 1.3-2.The Four Levers. The engineered agent loop — modeled state in, reasoning and action, a candidate output, fed around again. The four numbered levers are the engineering: the state exposed, the action surface, the success criterion, and the admission rule that decides whether the result advances.
Figure 1.4-1.The Derivation. Four foundation-model properties and four harness properties feed the two theses — broad reasoning, bounded context, and cheap upkeep yield the Modeling Thesis; probabilistic execution, tool mediation, and parallel throughput yield the Alignment Thesis. Read the arrows as "therefore": their combination requires the governed environment.
Figure 1.5-1.The Reassigned Seat. The conventional SDLC gives every seat to an engineering role; the SELC reassigns the developer's seat to the agent fleet. The engineer flanks the fleet — intent flows in as models, judgment and governance meet the output, and a governance band holds every seat's output.
Figure 2.1-1.The MAGE Stack. From the top: the Application (codebase, tests, CI), the Engineering environment (git and its hooks), the Harness (the agent's runtime), and the GenAI model at the foundation. The governance bar notches into every layer — a posture at all four levels, not one end gate.
Figure 2.2-1.The Model at the Apex. Left: the typical setup leaves docs, code, and tests as unconnected islands that drift. Right: the MAGE move puts a model at the apex, the one description the machine checks the others against — so a drift check fails the build when any disagrees.
Figure 2.2-2.The Semantic Gap. Bottom row: small events — single commits, calls, turns — where the property spreads across many, invisible in one, so enforcing here is the mistake. Top row: the whole unit of work, where it becomes checkable — lift the check to where meaning is legible.
Figure 2.3-1.The Governance-Conversion Loop. The loop that hardens the environment: when the printer loop keeps hitting one wall, judgment converts the failure class into a durable mechanism — the same loop shape as the printer loop, escalated.
Figure 2.3-2. The controls accumulate across four windows — lint files (0 to 336 to 595 to 747) and gate scripts (0 to 20 to 76 to 102). Both start at literal zero: the substrate is post-prototype. The climb is steepest through mechanization and rises after, one class at a time.
Figure 2.3-3.Constraint or Sensor. The two moves a quality goal splits into. A constraint makes a class of mistake impossible (a typed enum; a firewall), while a sensor lets it happen but detects it in time to retry (a CI suite; a smoke detector).
Figure 2.4-1.The Fenced Judgment Step. A run-measure-assess loop wraps a three-step spine: determinize the data space, apply judgment in reasoning space, then determinize the experiment space again. Fencing the one judgment step between deterministic ends bounds the messy part and logs a trace a checker can grade.
Figure 2.5-1.The Metric Spectrum. The harder the metric, the more a machine can block on it alone; the softer, the more it can only aim a reader who must still judge. The flagship sits in the middle: entry-point-native coverage, the deeper cut that names the untested invariant.
Figure 2.5-2.The Missing-Model-Metric Drain. The orphan rate — tests whose code reaches no model-anchored symbol — falls from 56% to 7.89% across nine tracer re-runs, each following an Epic that modeled the biggest remaining cluster. Coverage rises as the mirror image toward 92%, crossing the loop's ≤10% target.
Figure 2.6-1.The Conflict Is the Edge. Read Control A alone and it is correct; read Control B alone and it is correct. What they demand of the one resource they share collides — and that collision is drawn nowhere until the graph draws it.
Figure 3.1-1.One Trunk, Five Views. The trunk holds the shared machinery — executable source-of-truth, drift and parity gates, the agent-first harness — that makes every view executable and equal to the code. Five branches fan up: Logical, Process, Development, Physical, and Scenarios, the +1 that validates the other four.
Figure 3.1-2. 4+1 is one projection among siblings; a lens is a projection within one. Choosing a framework, or a slice within it, is a rendering decision over a single core — never a second model to maintain.
Figure 3.1-3. A model's value is both its schema and its checked invariants: the structured model declares predicates with stable ids, and a coherence-gate checks them at build time. The closing edge carries the proof — each invariant was earned from a failure the system never wrote down.
Figure 3.2-2. The service model feeds generators and parity gates. It is authoritative for what it generates and reconciled against reality for what it checks; either side diverging blocks the build.
Figure 3.4-1. The component registry feeds the boundary lints, dispatch, and context injection — every tool reads the same ownership answer — and a reverse-mapping test joins it to the real tree in both directions.
Figure 3.5-2.Profile Edit, Not Graph Edit. Correctness and cost-gate edges stay in the deploy graph; a load edge is banned and migrates to the Scheduler, which reads the per-host profile and emits the execution plan. Moving stress between hosts is a profile edit, never a graph edit.
Figure 3.6-1.The Four-Model Join. A journey's criticality derives its test tier, coverage joins on the same endpoint node, and the Scheduler rations the resulting set per host — parallel when only a cost gate applies, serialized when a scarce host is in play.
Figure 3.8-1.The Two-Layer Net. The model↔code gap spanned by two layers, with two escape hatches drawn as gaps in the net. Derived defends, snapshotted drifts — and what isn't modeled can't drift-check.
Figure 4.1-1.The wiki is the model you already have. Pages, links, and backlinks already form a graph; the first move joins it down to code and tests, the same round-trip join a structured model carries. Audit, Synchronize, Govern, and Extend mature the left panel into the right.
Figure 4.1-2.Audit, Drain, Promote. A new lint lands audit-only — every finding reported, no commit blocked, so it never breaks an in-flight agent. A fix wave drains it to zero, and only then is it promoted to blocking, so the class of smell can never return.
Figure 4.2-1.The Three Skills. One substrate, three complements: self-governance hardens it, self-operate runs it, self-communicate explains it — and the skills feed each other, a recurring break becoming a mechanism written in the register the third governs.
Figure 4.2-2.The Skill Skeleton. Every shipped skill has the same skeleton: a base model of the domain, orthogonal models cutting it along independent axes, and a SKILL.md of principles that ties them into a working skill.
Figure 4.3-1. The three skills share one skeleton: each carries an input to an output through sized transformations. Self-communicate stacks language and genre; self-operate maps event to design to launches; self-governance turns a symptom into a mechanism. Each step is sized to the model and the guarantee you need.
Figure 4.4-1.The Novelty Axis. A part's novelty sets the leap you can trust and the oversight you owe. At the standard end data is thick and a big leap is trustable; at the novel end data is thin, oversight grows, and up-front modeling is not optional.
Figure 4.6-1.A Point vs a Space. The example pins a point; the generative test models the space. One reproduces a dot the author already knew; the other states the law every dot obeys and lets a generator find where the code breaks it.
Figure 4.6-2.The Coin Is the Model. Fuzzing and property testing are two sides of one coin: both draw their oracle from the same shared specification, and coverage asks whether the generator ever reached the claims the model makes.
Figure 5.2-1. Commits per week across the project's history — the velocity curve. Each bar is one week; the curve rises as the fleet gains capability, then dips during hardening. That dip is where velocity is spent making the output trustworthy rather than merely fast.
Figure 5.2-3.The Support Ratio. Support-apparatus lines divided by production lines, across four windows: it starts below parity (0.85×), passes production at mechanization (2.48×), peaks during hardening (3.68×), then eases to 3.06×. The support line sits above parity for every mature window — governance led the fleet and kept pace.
Figure 5.2-4. Path churn across four windows — additions rise above the baseline, deletions fall below it, one bar per path. Mechanization is the add-and-delete peak; after it deletions collapse (backend/ from 286,378 to 3,767) and later windows go net-additive as the environment stabilizes the code.
Figure 5.3-1.LLM as a Function Call. A deterministic caller packs a task into a typed input; the model returns output under a typed contract; a validator passes it before use. Determinism on both ends makes the model safe to call: a bad generation costs a retry, never a corrupt result.
Figure 5.3-2.The Reactive Seam. Top: an event-driven flow — web enqueues chunks, a queue hands each to a stateless worker, a fan-in assembles the result. Bottom: the same flow two ways — the retired Kubernetes poll plane and the serverless push plane, native autoscale, no custom scaler.
Figure 5.3-3. The editor as one MVC loop over the document. A gesture flows View to Controller; the controller emits one typed edit op from a closed vocabulary; the model applies it and returns state to re-render the View. The same edit language is what the automated pipeline produces.
Figure 5.3-4.Two Producers, One Language. The human path emits ops by hand; the automated path turns a remediation task into an op through a task-to-edit function — an instance of LLM-as-function-call. Both emit the same closed edit vocabulary into one document model that applies and stamps each edit.
Figure 5.4-1.The MAGE Staircase. Each rung fixes the shortcoming that broke the one below; the ladder ends where the system is committed to explicit models held honest by a traceability substrate — MAGE.
Figure 6.0-1.The MAGE Dynamic Model. Eight constructs, read clockwise: capacity exercises environment E and drives work; work and E yield realized performance; the gap becomes governance pressure, then structural diagnosis, then adaptation, which reshapes E. Four numbered dynamics overlay it, legible in grayscale.
Figure 6.0-2.Bootstrap path. Inherited and anticipated knowledge establishes the initial governed environment before the fleet encounters project-specific failures.
Figure 6.0-3.Churn/discovery loop. Work outruns the environment; the resulting pressure becomes useful only when judgment recognizes a structural failure class.
Figure 6.0-6.Churn is non-monotonic in governance. Churn runs high when the environment is under-governed, reaches its lowest where the apparatus fits the risk, and rises again in the tower/collision region as controls duplicate and collide. Apparatus quantity is not effective environment quality; the curve is illustrative, not fitted.
Figure 6.1-1.The Soft–Hard Spectrum. Probabilistic mechanisms that aim an agent sit on the left; deterministic mechanisms that hold the line sit on the right. A mature environment uses both, and the skill is knowing which a given failure warrants.
Diagrams from the pattern-catalogue appendix, drawn in a lighter reference style.
Figure A.1-1. The provenance + fidelity stack in one picture. A document flows left to right through two lanes. The sanctioned door (fleet blue): MARK names every insertion so it is registry-covered; EMIT writes an attribution stamp for every mutation into the artifact. The guarantee (governed green): COVER's wiring lint holds the closed verb set at zero gaps; READ reconstructs the history from the embedded stamps; GATE asserts the input's content survives the output and names the pass that dropped it otherwise. Below the row, the artifact strip carries the stamps EMIT drops and READ and GATE read back. Mark it, cover the marking, read it back, and gate what leaves — provenance you can reconstruct from the artifact itself.
Figure A.2-1. The model-coherence stack in one picture. Six parts run left to right in two capability lanes plus the sealed-format part. Authoritative knowledge (fleet blue): DATA models the system as executable typed data; CONSUME reads it live and never snapshots; EMIT generates artifacts back from the model. Equal to reality (governed green): PARITY fails the build when a model and reality disagree either way; DERIVE anchors every model-to-code edge on a resolvable symbol a lint re-checks, so a derived edge cannot drift. SEAL (accent) routes all mutation of a shipped format through one typed model held sole by a ban-lint. The map is executable, read live, held equal to the territory, and generated back into it.
Figure A.3-1. The specification + verification stack in one picture. Six parts run left to right. The spec (violet): SPEC models the lifecycle as composed state machines and names the cross-machine invariants; CENSUS derives every obligation owed. The rigor tiers: PROVE (green) discharges the hairy invariants with an exhaustive check routed by each invariant's temporal form; LINT (blue) discharges the linear ones with a blocking semantic check at commit, and LEVEL (blue) aims each check at the granularity where its property first becomes legible. COVER (accent) projects coverage back onto the model's nodes, so a verified-in-principle invariant with no live test is a visible gap.
Figure A.4-1. The observe → react loop in one picture. Five parts run left to right. Observe (fleet blue): WATCH is the typed event bus every substrate emits onto; BEAT is the liveness channel that tells a hung process from a slow one. React (green): RESPOND is a written playbook per signal. Block (churn red): BLOCK refuses new work-dispatch while a high-severity alert is unresolved. Self-operate (accent): OPERATE is the positive map of how the substrate works. The bus says what happened; the playbook says what to do; the gate refuses to proceed until it is cleared; the map makes every signal interpretable.
Figure A.5-1. The resource-mediation stack in one picture. Four parts run left to right. DECLARE (violet) is the typed registry of concurrency contracts — what is serialized, what is single-writer. SERIALIZE (blue) is the host-level flock that admits one run of the heaviest tool at a time (N=1). SEMAPHORE (green) is the counting lock that admits up to eight concurrent runs of the adjacent heavy tools (M=8). SHED (accent) governs a saturable resource with a live pressure signal at two layers — an admission gate that refuses heavy work before dispatch and an execution shed that stops running work on a spike. The contract says how many; the mediators hold that many; the pressure gate decides whether they run at all.
Figure A.6-1. The governance-of-governance stack in one picture. Six parts run left to right. Model the estate (violet): GRAPH represents each control as a node tagged by trigger and resource footprint, with a conflict edge where two controls contend; REGISTRY attaches machine-readable metadata to each governance rule. Query the estate (green): CENSUS classifies each control by the target it guards, so a bare target is a re-derived gap; RADIUS makes each control declare its substrate assumption, so a change's blast radius is a computed query. Grow the estate (green): INTERPRET converts a recurring failure into a proportionate new control, fired on a cadence. Deliver it (accent): INDEX holds the governance document as a numbered, enforced, capped rule index in every agent's boot context.
Figure A.7-1. The context-management stack in one picture. Five parts run left to right, coloured by durability. INJECT (accent, 2026-transient) maps files-about-to-be-touched to their governing constraints and injects the slice into the brief. SNIPPET (blue, mixed) is the registry of mandatory brief snippets asserted at dispatch — transient delivery, durable enforcement. INDEX (green, durable) loads the numbered rule index into every boot context. HOOK (green, durable) binds a script to the runtime lifecycle so an omitted step fires deterministically. NUDGE (accent, 2026-transient) emits at most one tempo-gated reflection per window. The durable parts are infrastructure regardless of model; the transient parts ease as context windows grow.
Figure B.1-1. Accessible description: the brief and a registry of required markers both feed a brief-lint gate; when every required marker is present the agent is dispatched, and when any is missing the launch is refused before the agent starts.
Figure B.2-1. Accessible description: a slicing operator reads the constraint registries and runs in two directions — forward, mapping target files to the constraints injected into the brief before the agent writes, and reverse, mapping a diff's line ranges to the findings it introduced, which feed a self-heal gate.
Figure B.8-1. Accessible description: substrate emitters publish typed topics, drawn from a closed const-string registry, onto the event bus; the orchestrator polls the queryable surface, matches each event to its playbook entry, and takes the prescribed action.
Figure B.12-1. Accessible description: a turn-end event and a recurrence signal both feed a reflection hook that fires at most once per window — the hard, deterministic half. The hook prompts the soft loop: name the failure class, then decide whether a constraint is buildable; if so emit a typed seam or closed enum that makes the wrong move unrepresentable, else emit a sensor (lint, gate, test, hook) that detects and fails it. Either way the scaffolded control is handed to a human or the harness to install into the bounded rule index. A design-time audit prevents a class by construction before it is ever felt.
Figure B.14-1. Accessible description: two mechanisms each declare a substrate stance. A query joins those declarations against the substrate model and, for a migration target, emits the table of mechanisms that change puts in scope. The table is derived, not hand-maintained.
Figure B.16-1. Accessible description: the parity gate takes two inputs — the structured model and the enumerated reality on disk. It checks both inclusions: every model row exists in reality, and every real thing is modeled. When both hold the build proceeds; when either side diverges the build is blocked.
Figure B.17-1. Accessible description: one structured model that imports nothing feeds three consumers — an agent that reads it, generators that emit real artifacts from it, and a drift gate that blocks the build when the model diverges from reality. Continuous reads and checks keep it from staling.
Figure B.19-1. Accessible description: two mechanism nodes, each tagged by its firing event and its typed read/write/lock footprint, both touch one shared resource. Their collision is a typed conflict edge in a closed four-value taxonomy — contradiction, contention, ordering, soft-versus-hard. The edge's nature is derived from its conflict type: a mechanically decidable edge (contention, ordering) routes to a consistency lint or the pre-wiring check-new query; a judgment edge (contradiction, soft-versus-hard) routes to a human prompt. A drift lint re-resolves each node's code anchor so the graph tracks the wired mechanisms.
Figure B.22-1. Accessible description: a central model-element node is joined to four other node genres by typed, closed-vocabulary edges — enforced-by its lint, governs its code root, verified-by its proof or checker run, derived-from its registry, and points-at the live implementation. Every edge terminates on a resolvable SymbolAnchor of (path, symbol, resolver) that carries no line number, so it survives a refactor above it. A meta-lint re-resolves each anchor at definition-of-done or audit cadence and reddens a broken one. The same resolving anchors let an agent traverse the graph both ways — code to model, or model to code — on one index.
Figure B.26-1. Accessible description: a semantic lint scans the source tree for its invariant. A violation blocks the build; a clean scan lets it proceed. A scoped, reason-bearing suppression comment escapes a legitimate exception on a single line.
Figure B.27-1. Accessible description: a generator feeds adversarial bytes to the tool; coverage is collected and compared against a baseline so reach is measurable. A crash or corruption routes to a fix aimed at the stable spec point rather than the individual failing seed.
Figure E.1-1.The Skill Skeleton. A mastery-skill has three layers: a base model of the domain, orthogonal models cutting it along independent axes, and a SKILL.md of principles that ties them into a working skill.
