Every figure in the book — 68 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 book’s argument. The software-engineering case leads to theory, broader implications, and responsibility.
Figure 0.2-1.The six claims of MAGE. When engineers find themselves making the same judgment repeatedly, they can build it into a model or a control. Later work inherits that judgment, which can lower the cost of meeting the same obligation again.
Figure 1.2-1.Where engineering leverage acts. When engineers implement systems directly, much of their control acts through the code. With agentic implementation, more of that control acts through the governed engineering environment, which represents consequential intent, constrains work, and evaluates results.
Figure 1.3-1.DocAble from the user's view. An inaccessible document goes in; a remediated document and evidence of consequential changes come back. Internal structure is omitted because it is not yet relevant.
Figure 1.4-1.Commodity intelligence in a governed engineering environment. General capabilities from a foundation model become useful engineering machinery when connected to an agentic harness and a governed engineering environment. The environment contains both the existing system and the engineering structure used to guide and govern work. Engineers develop and maintain this environment.
Figure 1.4-2.Representation and the reasoning horizon. When relevant system knowledge exceeds a reasoner’s working state, it must be recovered for later decisions. Purposeful representations can reduce the work of recovering that knowledge. This may lower the cost of a task or make a larger task feasible.
Figure 1.5-1.From agentic machinery to MAGE. Finite working state motivates Modeling; probabilistic autonomous work motivates Alignment. The two principles address different engineering problems and operate together.
Figure 2.1-1.Requirements bound the acceptable implementation space. Each dot represents a possible implementation for lists of up to 1,000 names. Alphabetical ordering defines the left region, and the 200-millisecond response-time tolerance defines the right. Their intersection contains multiple acceptable implementations, leaving degrees of freedom such as the choice of algorithm.
Figure 2.1-2.Obligation, scaffolding, and degrees of freedom. The engineering obligation establishes the minimum consequential content that must be preserved. A particular agent may require additional scaffolding to interpret and satisfy that obligation reliably. Greater agent capability can reduce this scaffolding and leave more implementation choices open, but it does not change the obligation itself.
Figure 2.1-3.Three models of one sensor system. Structure shows where measurements flow, and quantities specify the rates and capacity. Putting the events on a timeline exposes the loss of the eleventh sample before the radio first runs.
Figure 2.1-4.Multiple routes to engineering models. A model may be constructed from requirements and intent, recovered from existing systems and experience, or discovered through agent exploration. However it arrives, the model carries engineering knowledge and the selected obligations drawn from it, and it can support three uses: engineers reason and design through it, agents are directed by it, and results are evaluated and checked against it. A model recovered from an implementation describes what exists; engineers judge whether its design is desirable and which discovered properties should become obligations. Further engineering discoveries may motivate new or revised models.
Figure 2.1-5.From engineering question to engineering consequence. Hold the system fixed and change the question, and the useful representation changes with it. The representation determines which analyses become tractable; analysis produces evidence that can inform architecture and design, expose a property for checking, or both. Chapter 3 takes up the separate question of which obligations should be enforced.
Figure 2.1-6.The engineering modeling repertoire. Familiar representations preserve different relationships for different engineering questions. Similar graphical forms can carry different semantics: an arrow may represent a dependency, transition, flow, permission, ownership relation, or derivation.
Figure 2.2-1.The structural move: entities and defined relations. This model states an intended architecture, rather than recording an execution. Every solid arrow denotes a direct dependency; the crossed arrow marks a forbidden bypass. Checking paths makes the obligation precise: every path from Web to Database must pass through API.
Figure 2.2-2.Document-mutation structural model. The reduction preserves one architectural relation: ordinary remediation reaches format-specific mutation through a structured-document seam. Enforcement of that relation is a separate Alignment decision.
Figure 2.2-3.From computations to composition. This illustrative fragment distinguishes data flow (solid arrows) from control dependencies (dashed arrows). Ellipses identify read-only computations, diamonds typed patch producers, and rounded boxes direct document edits. The apply seam is the boundary where patches are applied; the final alt-text check reports findings without changing the document.
Figure 2.3-1.The behavioral move: states and transitions. This example specifies an allowed job lifecycle: a job passes through Running before Succeeded, with retry and failure transitions describing other possible paths. The legend lists example properties to investigate.
Figure 2.3-2.Recovery-ordering model. A recovered artifact must be published to durable storage before the database may refer to it. The prohibited transition from FALLBACK_STAGED directly to DB_UPDATED illustrates the ordering violation; the property also excludes indirect paths that bypass FALLBACK_UPLOADED.
Figure 2.3-3.Ownership under contention. Worker A’s generation-7 claim expires and worker B acquires generation 8. A later release from A cannot clear B’s current claim. Recording the generation makes stale operations distinguishable from operations authorized by the current owner.
Figure 2.4-2.DocAble’s service-flow model. Arrows show selected permitted service invocations; asynchronous job dispatch is omitted. The web tier is the sole public entry point. Deployment configuration is generated from the full model, while runtime conformance requires separate enforcement.
Figure 2.4-3.The upload-entitlement domain. A finite balance alone cannot determine admission: the model must also preserve whether any applicable group grants unlimited use.
Figure 2.4-4.The admission check must preserve unlimited entitlement. Panels (1)–(4) explain the old representation, domain change, failure, and repair; they are not one runtime pipeline. In (3), the client uses the finite-credit total and ignores a separate unlimited signal. In (4), the same uncapped entitlement produces an admitting decision and a separate display value for unlimited use.
Figure 2.5-1.Three correspondence patterns. Derivation extracts models from implementation; generation produces implementation artifacts from models; traceability connects representations maintained independently. Each relationship covers selected properties or artifacts rather than necessarily determining the entire implementation.
Figure 2.5-2.Heterogeneous models over shared identities. An engineering question selects a path through the available representations. The highlighted traversal follows a service from its registry entry through deployment topology to performance measurements, using shared identities to connect the models. Other models remain available for different questions.
Figure 2.5-3.Computation structure versus recorded history. Declared computations and a run’s actual mutations answer different questions. A shared computation identity can join the recorded edits to the static model when needed, while preserving the distinction between what was declared and what happened.
Figure 2.5-4.The modeled surface and its limits. Models may represent properties that can be checked mechanically and properties that require semantic judgment. Properties outside the modeled surface have no model-based coverage. Over time, engineers can expand this surface by representing newly consequential properties or contract it by removing unnecessary distinctions.
Figure 3.0-1.Alignment from models to enforcement. Engineering models express obligations that the environment can enforce through constraints on actions or states, and through evidence evaluated at gates. Sensors obtain evidence from artifacts and executions, including through static and dynamic analysis. Gates can also require results from constraint checks. These functions may be combined in one mechanism; each governs only the obligations and evidence within its scope.
Figure 3.1-1.Intervention boundaries. Guidance influences reasoning; enforcement constrains actions or determines whether work and artifacts are accepted. Moving from individual actions to larger units of work can make additional obligations legible as evidence accumulates. Later boundaries are not necessarily stronger. Choose the earliest boundary where the obligation can be evaluated and enforced.
Figure 3.1-2.Dynamic context injection and enforcement. A dispatch hook selects initial engineering knowledge from anticipated files and components. After planning, the agent selects context again using its refined scope. Standing instructions remain available throughout. A Git precommit gate requires evidence of the second selection for the initial commit that permits implementation to begin.
Figure 3.2-1.Model agreement, obligation satisfaction, and admission. Correspondence concerns agreement between an engineering model and its implementation; conformance concerns satisfaction of an independent obligation represented in the model. Acceptance is the GEE's decision to permit the implementation to proceed, based on applicable controls and evidence that may extend beyond the model shown. Evidence for one relation does not establish the others.
Figure 3.2-2.The semantic gap. Different obligations become decidable at different boundaries. Model–implementation correspondence may be required at task completion even when intermediate commits legitimately disagree; rendered-page correctness requires an integrated execution that earlier source, build, and API checks cannot establish. Place each check at the earliest boundary where sufficient evidence is available.
Figure 3.3-1.Governance around a proposed change. Module restrictions limit the implementation; instrumented tests produce evidence; the merge gate checks the required results before accepting the change. The checks' coverage limits the assurance they provide.
Figure 3.3-2.Two protections in DocAble’s job-recovery protocol. A durable compare-and-set prevents competing workers from acquiring the same claim for a protected effect. A bounded explicit-state checker examines recovery interleavings, including whether a stale release can clear a newer worker’s claim. The runtime constraint directly restricts execution; the checker evaluates the modeled protocol. Tests provide separate evidence about the implementation.
Figure 3.3-3.Margin and engineering freedom. A quantitative model establishes a response-time tolerance of 200 ms. Alignment measures two implementations against that bound: A has 80 ms of margin, while B has 5 ms. Both conform, but their remaining headroom differs. The measurements can guide an agent’s exploration of implementation alternatives and inform the engineer’s subsequent design and governance decisions. Measured margin is evidence about available freedom, not a guarantee.
Figure 3.4-1.Governance conversion. When a failure exposes a recurring failure mode rooted in missing representation, obligation, evidence, evaluation, or enforcement, encode the missing structure at the appropriate layer. Future work inherits the result as engineering capital when that durable structure continues to lower future cost or uncertainty.
Figure 3.4-2.Where enforcement stops. An obligation may remain unrepresented, require expert judgment, be evaluated without enforcement, or be governed. These are possible dispositions, not equally desirable outcomes.
Figure 3.5-1.Three views of the control machinery. A catalogue identifies controls; an interaction graph relates controls through shared resources and exposes potential conflicts; and a coverage view relates controls to independently identified engineering obligations. The same control identities appear across all three views. Coverage analysis can reveal obligations lacking adequate controls (coverage gaps) and controls lacking a current justification (candidate orphans).
Figure 4.1-1.Engineer–agent interaction through Modeling and Alignment. Engineers communicate intent and knowledge through natural language, specifications, and models; delegated realization returns evidence through review, testing, and analysis. The channels are complementary rather than sequential. Modeling makes selected engineering knowledge available to guide realization, while Alignment provides evidence for evaluating and revising it.
Figure 4.1-2.Active and passive alignment. Active alignment brings an implementation into conformance with modeled obligations, including newly introduced obligations that deliberately differ from the current system. The retained models, mechanisms, and governance become engineering capital when subsequent changes benefit from them. Passive alignment uses them to evaluate subsequent changes and preserve the properties already brought under governance.
Figure 4.1-3.Incrementally extending the alignment kernel. The kernel contains the modeled properties that must already be protected while active alignment changes the system. Additional models extend the governed surface, but each new alignment operates subject to the constraints established by the models already in the kernel. The layers are not different classes of model; they show models such as those introduced in Chapter 2 becoming governing constraints over time.
Figure 4.1-4.Agentic engineering through models. Modeling, realization, and evaluation recur as a system evolves. Alignment operates throughout; governance conversion can make a consequential lesson durable during any activity.
Figure 4.2-1.Three stages of DocAble's document processing architecture. (a) Initially, one worker retained the complete document, including its media. (b) Page chunking reduced the working set per worker, but each chunk still retained its media. (c) Skeletonization separated document structure from media, retaining only structure and references in worker memory while streaming media on demand. Chunking changed the execution unit; skeletonization changed the residency requirement.
Figure 4.2-2.Two execution policies over the same remediation graph. The graph contains actions—page analysis, construction of document context, and GenAI queries—and information dependencies among them. (a) A page partition groups actions by the page their artifacts occur on, so it can span several dependency levels. (b) A frontier groups actions by readiness: page analyses execute first, their results enable construction of document context, and that context enables independent GenAI queries for alt text. The work and its dependencies are unchanged; only the execution boundary changes — so the choice between (a) and (b) is a scheduling decision, not a remediation redesign.
Figure 4.2-3.Analyzing dependency graphs to redesign execution. (a) Critical-path analysis identifies the longest weighted dependency chain, which sets a latency floor of 12 seconds in this illustrative graph. Two possible responses are shown. (b) Decomposing the dominant operation into independent suboperations reduces the modeled critical path to 7 seconds, excluding coordination overhead. (c) Changing the information dependencies can remove a serial constraint altogether. In DocAble’s image-description pipeline, replacing propagation of previously generated descriptions with shared rendered context allowed the image-description operations to proceed independently.
Figure 4.2-4.The GenAI critical path in a schematic fragment of DocAble’s remediation graph. Independent remediation computations can execute concurrently, but section summarization, document summarization, and alt-text generation form a dependent chain. For the modeled workload, their estimated and measured durations contribute approximately 7.7 seconds of serial latency, which additional workers alone cannot eliminate.
Figure 4.2-5.Modeling through prediction and measurement. (a) An engineering problem motivates a model whose analysis informs implementation. Measurements test its predictions and may require the model to be revised. (b) A discrepancy between predicted and observed latency directs investigation toward an incorrect parameter, an incorrect relationship, or a missing mechanism. The numerical values are illustrative. (c) The revised model is tested again until its residual is acceptable for the question being investigated.
Figure 4.3-1.Discovering latent models in an existing system. Weak signals identify candidate locations, not prescribed remedies. Repeated concepts worth modeling gain explicit representations; consumers migrate to them, and narrower checks can enforce selected obligations. Each pass leaves a stronger basis for subsequent recovery.
Figure 4.4-1.Model-aware change impact. A proposed concurrency change leads through related execution, memory, and latency models to potentially affected obligations and the evidence needed to evaluate them. These relationships guide validation effort; incomplete or stale relationships can require broader checks before admission.
Figure 4.4-2.Separating integration from broad validation. Shaded boxes identify validation work; initially, full validation delayed subsequent changes. The redesigned pipeline runs inexpensive checks before each merge, broad checks periodically against accumulated changes, and full validation before deployment. Separating these schedules reduces repeated computation and blocking latency, but delays detection of failures that escape the per-merge checks.
Figure 5.1-1.Two problems of factory engineering. Process design determines how production proceeds around the fabricator. Tolerance identifies acceptable variation in what the factory produces; measurement establishes whether a realization remains within those bounds. The two concerns are complementary: a production system may carry engineering knowledge in the organization of production, in explicit bounds on the resulting product, or in both.
Figure 5.2-1.The build, in stages. DocAble expanded from a feasibility probe through format support, institutional operation, and hardening. Each stage introduced obligations that changed the product and the environment governing its implementation.
Figure 5.2-2.Development activity and engineering structure over 31 weeks: (a) reconstructed landed work commits; (b) declared models, consumers of multiple models, and registered static and dynamic verifier files; (c) recovered dispatches; (d) documented Epic completions. Shaded intervals lack retained records and do not establish zero activity. Activity and inventory counts describe the factory’s growth, not the value or correctness of its output.
Figure 5.2-3.The product and its supporting apparatus: composition at ten sampled revisions. The support ratio is apparatus divided by production: about 2.6× at week 11, 3.6× at week 21, and 3.8× at week 31. Lines between samples interpolate; the apparatus’s size establishes investment, not its return.
Figure 5.2-4. Substitutable reasoning, controlled mutation. Different reasoning strategies inspect the document model and propose supported edits through a common typed changeset interface. A controlled applier executes those edits; provenance and independent validation provide evidence about the result. The drawing shows the PDF changeset path. Some PDF operations still mutate directly outside this interface.
Figure 5.2-5.From engineering intent to completed work. The orchestrator schedules independent phases from a reviewed work order, then a separate agent audits their combined result against the completion criteria and returns missing or defective work for repair. Closing the work order and authorizing deployment are separate decisions.
Figure 5.2-6.DocAble’s delegation staircase. As the governed engineering environment (GEE) acquired models, checks, and controls, my work shifted from inspecting and admitting individual changes toward directing implementation and making system-level decisions. The three stages summarize DocAble’s development rather than prescribe a maturity model. Failures in the environment could still require direct inspection.
Figure 5.3-1.Remediation compared with the human reference: (a) median reduction in checker findings from the original; (b) frequency of increased findings; (c) semantic comparison of DocAble and human outputs under the project rubric; (d) criterion-level gains and regressions relative to the original. Percentage reductions exclude documents with no original findings. Parity denotes similar measured improvement, not equivalent accessibility.
Figure 6.1-1.Probability in the software factory. Engineers encode consequential intent; agents fulfill the encoded obligations. The two probability terms condition on representation , omitted for legibility. The encoded property also defines the acceptable region for realizations, allowing independent evidence to inform admission or rejection.
Figure 6.1-2.The MAGE Dynamic Model. Prior engineering knowledge seeds the governed engineering environment (GEE). Work orders specify intended changes, agentic capacity enables their implementation, and the GEE governs attempted work. Observed problems can prompt diagnosis and governance adaptation, revising the environment inherited by later work. An improved GEE may also support more ambitious tasks, exposing new demands on its representations and controls.
Figure 6.2-1.The Determinization Frontier. Alignment can bind a property that is already decidable. Modeling can change the representation so that a property previously requiring semantic reconstruction becomes decidable and can then be bound by Alignment. Both routes move repeated judgment into machinery.
Figure 6.3-1.Choosing where to invest in explicit engineering. The value of making an obligation explicit and its mechanizability suggest four responses, illustrated by examples. Better models and evaluation can increase mechanizability, while cheaper engineering machinery can make investment economical at lower expected benefits. Neither change implies that every obligation should be mechanized.
Figure 7.1-1.Where Engineering Effort Moves. As the fleet assumes work across the lifecycle, the engineer increasingly works through the surrounding engineering environment: specifying intent, choosing consequential abstractions, evaluating evidence, resolving tradeoffs, and adapting the environment itself.
Figure 7.2-1.Established traditions, new composition. MAGE draws on two long-running traditions. Engineering disciplines developed explicit models, constrained representations, verification, and external control; AI repeatedly extended reasoners through knowledge representation, planning state, memory, structured reasoning, tools, and surrounding machinery. MAGE brings these inheritances together around autonomous software work: Modeling makes engineering knowledge explicit, Alignment enforces selected obligations independently, and both meet in the Governed Engineering Environment. Governance conversion carries recurring judgment into durable engineering capital within that environment.
Diagrams from the pattern-catalogue appendix, drawn in a lighter reference style.
Figure A.2-1. The deployment dependency map and runtime identity determine the IAM grant plan; deployment reports each grant’s application result. The service-flow model is checked for parity with the map. Declared/live service-name correspondence is a separate check, not verification of IAM bindings.
Figure A.3-1. A work order is refused when its resolved phase is recorded as DONE, unless a valid explicit override is supplied. Missing or unresolved state does not establish completion. Reopening sets the phase to queued; an override permits one dispatch and attempts a best-effort audit write. Dispatch repeats the check.
Figure A.4-1. Supported typed edits share a controlled application path. A pipeline, agent, or human editor can propose changes against the document model. The PDF applier checks selected restrictions and applies or refuses operations individually; results and applied-edit attribution describe what occurred. Some internal remediation still edits directly.
Figure A.4-2. A structured work order selects applicable engineering knowledge from maintained models. Brief validation precedes dispatch; the agent implements and commits. Completion review compares landed work and independent check evidence with the work order, then updates its status. An agent report alone does not establish completion.