Key Concepts

The canonical vocabulary for Architects of Intent.

The book introduces this canon iteratively. If you are reading linearly, do not try to load every term at once. The Philosophy page states the whole system in compressed form; this page is the tiered map back to the chapters.

This canon is intentionally tiered:

In practice: learn Tier 1 first, expect Tier 2 once the loop is real, and reach for Tier 3 when autonomy, policy, and protected surfaces start to matter.

Most entries are concrete concepts. A few are marked explicitly as a Frame, Rule, or Pattern when they describe how concepts compose rather than naming one artifact.

Core Thesis (Intent -> Map -> Loop -> Convergence)

Tier: 1

What it is A compact statement of Software Development as Code (SDaC) mechanics:

  1. Intent starts as language.
  2. Intent is formalized into Maps (Mission Objects, specs, schemas, policies, inventories).
  3. Loops execute Maps against Terrain under Physics.
  4. The Ledger records evidence for each state transition.
  5. Terrain updates become tomorrow’s Maps through sync/update loops.
  6. Governance keeps loops converging instead of drifting.

Why it matters It turns fast generation into bounded, auditable progress toward better states.

Map / Terrain / Ledger

Tier: 1

What they are

Why they matter Autonomy is safe only when intent (Map) and reality (Terrain) are explicit, and every change is traceable (Ledger). Without Map/Terrain synchronization loops, today’s Terrain becomes tomorrow’s stale Map. Without a legible Ledger, memory collapses into folklore.

Operating Map

Tier: 2

What it is The higher-level Map of an organization: strategy, architecture decisions, operating policy, incident learnings, onboarding guidance, brand voice, tone, culture, and other durable constraints that say what the system is trying to preserve. It is the organization’s executable memory, not just its documentation.

Why it matters Without this Map, loops optimize locally and relearn the same lessons. With it, evidence can become future defaults, not just yesterday’s ticket, and future work can start from a truer organizational memory.

Physics

Tier: 1

What it is Deterministic constraints that shape a stochastic process: schemas, linters, tests, architectural rules, gates, budgets, and stopping conditions.

Why it matters Physics turns “seems fine” into PASS/FAIL signals the system can act on. In operation, Physics is law: if a change fails Physics, it does not exist.

Mechanism

Tier: 1

What it is A specific, checkable implementation detail (a validator, a parser, a build target, a CI gate) — not a metaphor.

Why it matters This book earns trust by cashing claims out into mechanisms you can run.

Deterministic Sandwich

Tier: 1

What it is The unit pattern for safe autonomy: pin one stochastic call between two deterministic layers.

  1. Prep: normalize the Mission Object and assemble a bounded context slice.

  2. Model: one bounded stochastic generation step.

  3. Validation: parse strictly and run validators; accept only if admissible.

Validator

Tier: 1

What it is One deterministic gate: a linter, a type validator, a schema validator, a contract test, or a policy validator.

Immune System

Tier: 1

What it is The suite of Validators that defines “good enough” for a surface.

Why it matters It moves you from “looks good” to “passes,” which makes loops auditable and repeatable.

Immune System case

Tier: 1

What it is One concrete PASS/FAIL case inside the Immune System suite (a test case, a contract check, a policy rule, or a schema validation).

Effector

Tier: 1

What it is A bounded transformation that proposes a patch/diff to the Terrain (or a Map surface) under constraints.

Sensor

Tier: 1

What it is A read-only measurement of the Terrain that emits structured signals (counts, diffs, failing invariants, hotspots).

Mission Object

Tier: 1

What it is Typed intent and state: goal, scope, constraints, budgets, quality gate, fallbacks, telemetry, relevant prompts or prompt-template references, plus lifecycle fields (for example status and completed_at). A persistent artifact (YAML/JSON) that acts as an executable pull request and the state of record for one unit of work. It is the artifact that moves through the loop.

Why it matters It moves intent out of chat and into a bounded, rerunnable, reviewable artifact that can survive retries, judgement, escalation, and later reuse.

Judge

Tier: 1

What it is Consumes validator signals + evidence and decides the next move.

Adaptation State Machine (ASM)

Tier: 1

What it is The allowed moves after Judgement:

Why it matters Explicit state transitions make loops deterministic and finite: no silent failure modes, no infinite retries, no “keep going until it feels done.”

Agent

Tier: 1

What it is A model running inside a constrained environment with explicit Tools, Physics, and a Ledger. It does not “want” anything; it executes a loop.

Engine

Tier: 1

What it is The full SDaC system: substrate + Sensors + Effectors + Immune System + Judge + Ledger. The Agent (model) is one component inside the Engine, not the system itself.

The Three-Tier Frame (Substrate → Loop → Governance)

Tier: 2

Kind: Frame

What it is A compact frame for SDaC systems: Substrate (Map/Terrain/Ledger + Physics + Context Graph), Loop (Deterministic Sandwich + feedback-driven refinement), and Governance (blast-radius limits + protected graders).

Why it matters It’s a completeness check: if you’re missing a layer, autonomy fails in a predictable way.

Don’t Chat, Compile

Tier: 2

Kind: Law

What it is Shift interaction from ephemeral chat to executable artifacts: Missions, deterministic runners, diffs, and logs.

Why it matters It makes intent reproducible and makes provenance cheap.

Skeleton-First Rule

Tier: 2

Kind: Rule

What it is Extract structure deterministically; generate prose stochastically.

In practice: build Maps on a skeleton of facts computed by Sensors (deterministic extractors: AST-extracted signatures, routes, schemas, inventories). The model is allowed to add “flesh” (descriptions, formatting, bounded implementation) but must not invent the skeleton.

Why it matters If the model is allowed to generate structure, it can invent facts and feed them back into the loop as “context.” Over time, the system converges on a self-consistent story instead of reality.

Mechanism Treat skeleton mismatch as a hard failure: re-extract the skeleton from the proposed Map and require exact match against the Sensor output.

Map Contamination

Tier: 2

What it is The failure mode where generation contaminates what later steps treat as extracted fact: invented skeleton facts enter the Map, then reappear as “authoritative context” in later runs.

Why it matters It corrupts the Ledger with plausible fiction. Validators and Judges can’t reliably debug or govern a system whose context is no longer grounded in the Terrain.

Recursion

Tier: 3

Kind: Pattern

What it is The same toolchain used by humans is used by maintenance loops (Dream Daemon emitting Missions, the loop validating itself under Immutable Infrastructure boundaries).

Why it matters It turns maintenance into a pipeline instead of a calendar reminder.

Stochastic Drift

Tier: 2

What it is Variance in output and behavior under the same Mission Object and context slice.

Why it matters Drift is the default. The question is not “how do I remove drift?” but “how do I constrain it so it becomes safe to integrate?”

Drift Coefficient

Tier: 2

What it is A simple metric for measuring stochastic variance across repeated runs of the same Mission Object:

drift_coefficient = unique_diffs / total_runs

Why it matters It turns drift into a measurable system property. You can set thresholds, compare changes, and track whether your Physics is actually reducing variance.

Ouroboros Protocol

Tier: 2

What it is The iterative loop: Write → Judge → Refine until convergence or a circuit breaker. It is called Ouroboros because the loop feeds its own artifacts back into the next turn and evolves through that feedback, rather than repeating as a static circle. Refine is a constrained mutation step in response to a specific failure signal, producing a smaller, cleaner diff.

Convergence

Tier: 2

What it is The state where the loop produces an output that passes Physics and satisfies the Mission Object’s acceptance criteria. The opposite is thrashing: iteration count goes up, but errors do not decrease. Operationally, convergence means moving toward near-optimal states for declared objectives, constraints, and budgets.

Why it matters It lets you distinguish productive loops (moving toward PASS) from waste (spinning without progress), and it gives you a clear stop condition.

Attractor

Tier: 2

What it is System geometry for “Done”: an attractor is the region of solution space where your Immune System is satisfied (the candidate parses cleanly, stays in scope, respects budgets, and passes every Validator).

You can think of it as a “valley” the loop settles into once the constraints are well-posed.

Why it matters It turns thrashing from “bad luck” into a debuggable failure:

Circuit Breakers

Tier: 2

What they are Hard stop conditions that keep loops finite: max iterations, max wall-clock, max diff size, min progress.

Review Budget

Tier: 2

What it is A cap on human review throughput allocated to autonomy (for example max open agent PRs, max agent PRs per day, diff size limits, and staleness windows).

Why it matters When the review queue collapses, governance becomes rubber-stamping. Review Budget turns “review throughput is the bottleneck” into a first-class constraint you can enforce.

Structured Error Objects (Signal-Rich Failure)

Tier: 2

What they are Machine-readable failures (file path, line, error code, failing validator, suggested fix) rather than vague strings.

Why they matter The cost of a loop is inversely proportional to the precision of the Judge.

Feedback Injection

Tier: 2

What it is Feeding the exact failure signal (stderr, linter output, failing test lines) back into the next iteration — ideally normalized into Structured Error Objects.

Why it matters It turns “try again” into targeted correction.

Quarantine

Tier: 2

What it is A designated directory pattern (for example .sdac/workflow-quarantine/) where failed attempts are archived with their diffs, logs, and validator output instead of being deleted.

Why it matters It preserves useful fragments for manual recovery or analysis without re-running expensive model calls.

Salvage Protocol

Tier: 2

What it is A loss-aversion mechanism: the Quarantine directory pattern plus the habit (and tooling) to search it and recover useful fragments from failed runs.

Intent Architecture

Tier: 2

What it is Engineering how intent moves from language to execution: Mission Objects + Maps + Directives compiled into bounded diffs under non-bypassable Physics.

Intent is the attractor. It answers:

Why it matters If intent is implicit or scattered, autonomy becomes unsafe and un-auditable. Intent Architecture makes the “what” replayable; Context Architecture makes the “evidence” admissible.

Context Architecture

Tier: 2

What it is Engineering how context is selected, structured, and bounded so a model can act deterministically, including which slices of the operating Map belong in one task.

Lehman’s System Types (S, P, and E)

Tier: 2

What it is Meir M. Lehman’s 1980 classification of software based on how its correctness is verified and how it evolves: - S-Type (Specifiable): Software whose correctness is absolute because it is derived from a formal specification (for example, a sorting algorithm, a schema validator, or a parser). - P-Type (Problem-solving): Software that approximates a solution to a real-world problem using heuristics. Perfect specs are impossible, so correctness is evaluated by acceptability (for example, a chess engine or a large language model (LLM)). - E-Type (Evolutionary): Software embedded in the real world. Because the environment changes, the software must continuously adapt or it degrades (for example, your production codebase).

Why it matters It provides the theoretical baseline for SDaC. LLMs are P-Type heuristic engines. Your repository is an E-Type system. You cannot mathematically prove an E-Type system is safe; you can only govern it. Safe autonomy requires isolating logic into S-Type components (which Hard Physics can gate) so that the E-Type whole can be safely managed by P-Type agents.

Branching Factor (Rule of Seven)

Tier: 2

What it is A simple topology heuristic for Map/Terrain structure and Context Graph slices: aim for ~7 (±2) siblings per conceptual layer (directory children, heading siblings, grouped constraints).

Why it matters Too high and you get junk drawers (signal dilution). Too low and you get rabbit holes (token waste on traversal). A healthy branching factor keeps slices queryable and reviewable.

Mechanism Measure fan-out deterministically and lint it:

# Directory fan-out: immediate children at this layer
find services/api -maxdepth 1 -mindepth 1 -print | wc -l

# Doc fan-out: sibling sections at this layer
rg -n '^### ' docs/feature_x.md | wc -l

Context Graph

Tier: 2

What it is A queryable topology of the codebase. Nodes represent units (apps, packages, modules, surfaces) and carry identity (language, framework, build tooling). Edges represent dependencies and contracts. Slices are derived deterministically for one task.

Context Packet

Tier: 2

What it is A Mission-specific context bundle derived from the Context Graph: anchor nodes, included Map/Terrain surfaces, excluded surfaces with reasons, budgets, and provenance (commit hash, extractor/tool versions, and a graph snapshot identifier).

Why it matters The packet is what the model actually sees. It makes context selection auditable and reproducible.

Directives

Tier: 2

What it is Human-authored behavioral laws for the Agent (for example agent_directives.md). Unlike Physics (enforced mechanically), Directives are enforced by the agent instruction layer and review policy. They define “who you are” and “how you act,” not just what to build.

Why it matters They cover constraints that are hard to validate mechanically (tone, style, approach) but still critical for output quality and operator trust.

Driver Pattern

Tier: 2

What it is A translation layer that decouples intent from mechanism. The Mission says “run tests,” and the system selects how (pytest, vitest, mvn test) based on the repository substrate.

Why it matters It keeps Missions portable across stacks and prevents tool-tour prompting (“use vitest”) from leaking into intent.

Map-Updater

Tier: 2

What it is Sense → Normalize → Compare → Propose patches to keep Map surfaces synchronized with the Terrain.

Why it matters It closes the recursion: yesterday’s Terrain can become tomorrow’s trusted Map.

CI Gate (Map–Terrain Sync)

Tier: 2

What it is Operational enforcement: divergence between Map and Terrain becomes a build failure, identical to a syntax error.

Mission Gate

Tier: 2

What it is A CI check that runs a Mission’s acceptance criteria (Physics) without running the model. It answers: “Would this diff be admissible?” independent of who authored it.

Why it matters It decouples Validation from Generation and gives you an impartial judge for both human and AI changes.

Cache

Tier: 2

What it is Crystallized state (snapshots of slices, reports, and derived views) to avoid re-computation and preserve replayability.

Provenance

Tier: 2

What it is The metadata trail that makes a run reproducible: commit hash, context slice identifiers, tool versions, Mission Object ID, timestamps, validator versions, and, when governance surfaces move, which protected or constitutional surface changed and who authorized the change.

Why it matters Without provenance, you can’t reliably reproduce failures or prove that a loop ran under the constraints you think it did. You also lose the ability to explain how the rules themselves changed.

Immutable Infrastructure

Tier: 3

What it is Protected paths and pipelines that grade and govern the system (validators, CI, policy). The system can propose changes, but cannot merge or weaken them without human approval.

Why it matters It keeps autonomy delegated, not sovereign. The loop may act inside the constitution, but it does not get to rewrite the constitution on its own.

Scope Guard

Tier: 3

What it is Blast-radius control enforced by the system: the agent is only allowed to write to an explicit allowlist of paths (the Mission scope), with all other paths denied.

Why it matters It prevents scope leak and makes autonomy safe enough to run unattended.

Ratchet

Tier: 3

What it is Monotonic quality metrics: metric_new ≥ metric_old for specific guardrail metrics (coverage floors, security gates, policy boundaries).

Neuroplasticity (Safe Self-Modification Capability)

Tier: 3

What it is The system-level capability to absorb refactorings and other self-modifications without collapsing into regressions.

Refactoring is the action. Neuroplasticity is the capability.

Why it matters Without this capability, autonomy turns into churn: the system can change itself, but cannot reliably stay correct, safe, or reversible as it changes.

Mechanisms (how you build it)

Dream Manifest

Tier: 3

What it is Measurable maintenance targets: a versioned entropy backlog expressed as concrete work selectors and memory updates.

Why it matters It turns recurring incidents, review comments, and drift signals into durable maintenance memory instead of letting them disappear into chat or tickets.

Dream Daemon

Tier: 3

What it is Scheduled background maintenance: a controller that turns entropy signals into bounded maintenance work. Most teams start with the “90% solution”: human-approved scheduled runs.

Why it matters It keeps the operating Map and the Terrain from drifting apart between incidents, and it gives the system a way to preserve lessons instead of relearning them.

Automated Refactoring Under Guards

Tier: 3

What it is Measure → Mutate → Measure → Commit/Revert under strict Validators, blast-radius limits, and Immutable Infrastructure boundaries.

Hofstadter Bridge

Tier: 3

What it is The boundary where documentation becomes executable constraints: the Map is no longer advisory; it is enforced. In practice, teams cross it one bounded surface at a time: one heading, one extractor, one gate.

Mirror

Tier: 3

What it is An optional advanced case: a system can treat its own operating Map, or a formal derivative of it, as an input to its maintenance and governance loops.

Torus

Tier: 3

What it is Bounded autonomy under governance. The governed path by which declared intent meets changing reality and, through memory, validation, and adaptation, converges on the best state that can actually be reached and proved. In practice, it is not one loop but many bounded loops running in parallel across the organization at different levels of abstraction.

Why it matters It distinguishes an organizational second brain from a static knowledge base. The system does not just store memory; it uses memory, tests it against reality, keeps it alive, and turns it back into action. It also gives a shape to organizational scaling: code loops, maintenance loops, policy loops, and strategic loops can all run under the same constitutional pattern without collapsing into one monolithic process. It is also where value compounds: accepted changes improve the memory, gates, and defaults that shape future accepted changes.

Translation guide (one-time bridge, then use canon)

Share