Key Concepts (v4)

The canonical vocabulary for Architects of Intent v4.

This canon is intentionally tiered:

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).

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.

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, 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.

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

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.

Meta-Pattern: Don’t Chat, Compile

Tier: 2

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.

Meta-Pattern: Physics is Law

Tier: 2

What it is The stance that Physics is enforced, binary, and non-bypassable. If a change fails Physics, it does not exist.

Why it matters Autonomy exploits loopholes. “Law” closes them.

Meta-Pattern: Skeleton-First Rule

Tier: 2

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.

Meta-Pattern: Recursion

Tier: 3

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. 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.

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.

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.

Context Architecture

Tier: 2

What it is Engineering how context is selected, structured, and bounded so a model can act deterministically.

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.

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, and validator versions.

Why it matters Without provenance, you can’t reliably reproduce failures or prove that a loop ran under the constraints you think it did.

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 them without human approval.

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: an entropy backlog expressed as concrete work selectors.

Dream Daemon

Tier: 3

What it is Scheduled background maintenance. Most teams start with the “90% solution”: human-approved scheduled runs.

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.

Mirror

Tier: 3

What it is The optional limit case: a system can treat its own book/spec as an input to its maintenance and governance loops.

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