Glossary

a participant that exercises judgment or performs work in a workflow. LLM actors have context windows; humans have their own attention and information constraints. Deterministic tools participate but exercise no judgment of their own. (context economy, human-in-the-loop gate)

the event that loads an artifact into a window. (context flow)

a pairwise predictive profile between a task and a context space, with at least two readings: reusable overlap and conflict risk. It is estimated before co-scheduling; relevancy is the resident state observed afterward, and alignment is the pattern that acts on the estimate. (context alignment)

the skill shape one altitude up: name + description + body defining a dispatchable actor; may carry authored weight. (heavy agent)

how much of the world sits inside an effect's footprint; what compensation costs when a run must be unwound. Bounded by the seam the effect landed at — a contracted seam prices the discard cheap. (effect discipline, contract documentation)

the corpus's way of saying which model without naming one: an ordering, never a set of named buckets. A node says same class, lower class, higher class and never has to say what "frontier" means — an ordering with no named levels has nothing in it to go obsolete on a vendor's release schedule. One superlative is admitted, for a claim with no second model to be read against: the highest class the claim's own dated evidence covered, which is why it is only available to a claim that names its evidence. Relational ratios stay primary; class is reached for only where a ratio cannot reach. The node speaks in classes and ratios; the research memo names the exact model, version and date. (ADR 0018)

human-authored, agent-read declared preferences; what an episodic skill bootstraps from. (config-as-bootstrap)

which party an artifact crossing a seam is shaped for: agent-forward (a reasoning stage) or user-forward (the human). Exists only where a move hands an artifact downstream. (externalizing tools & systems, distillation)

a distilled artifact handed across a seam: payload + declared shape + provenance. (context envelope)

the designed expression of expectations at a seam, ranging from informal prose to mechanically enforced structure. Every seam has an interface; only the needed share must be made explicit. (the contract)

moving when or by whom a payload's cost is paid: later (deferred context) or elsewhere (subagent offload). Relocation and transformation are orthogonal; a workflow may compose relocation with selection or distillation. (cost relocation)

what fraction of a task's actual intent the written clauses at a seam capture; orthogonal to per-clause checkability (the determinism ladder). Raising it is contract-side craft; clause-writing that stops paying before intent is captured is coverage exhaustion. (verification asymmetry, the contract)

the request that creates and initializes a child LLM execution. Its inputs include manually packed, inherited, and ambient context. (LLM dispatch)

a top-level navigational grouping. It is not a node kind and need not imply that every sibling shares one classification axis. (patterns index)

running in discrete, independent invocations with no memory between them. (config-as-bootstrap)

how residency ends: compaction, summarization, truncation, a dispatch returning, or a session ending. Eviction ends recall from the artifact; decay can reduce recall efficacy while the artifact remains resident, but is not eviction. (context flow)

the former name for a top-level domain; retained in prose where useful, but not treated as a node kind. (patterns index)

a contracted control-flow seam for human clarification, approval, or escalation; not a child LLM dispatch. (human-in-the-loop gate)

does the move produce an artifact handed to someone downstream? Passing moves (externalization, distillation) carry consumer orientation; agent-internal moves don't — "user-forward composition" is a category error. (externalizing tools & systems)

always-on context admitted at boot into every descendant actor's window: system prompt, CLAUDE.md / memory-file lines. No downstream actor chose it and none can evict it — the widest propagation scope, hence the system's highest admission bar. (context economy)

what a spec node is: concept / pattern / example. (AUTHORING §1)

the propensity to continue the resident trajectory: the window steers generation, not just informs it. Sign-neutral — the same force behind in-context learning (pointed well) and doom loops (pointed wrong); distinct from friction (conflicting content, always negative). Fresh dispatch = zero momentum — which is also the identity test: steering that survives a reset is the model's prior, not momentum. (momentum)

the smallest structured evidence sufficient to reconstruct what governed a run, what context/tools influenced it, what effects occurred, which checks passed or failed, and where failure originated. It favors receipts and manifests over retaining every intermediate token. (ADR 0009)

the role currently holding a larger objective and coordinating bounded parts. It is a relative control role, not a permanent actor type. (workflow decomposition)

relative positions on one LLM dispatch edge: the parent creates a distinct child execution; that child may become a parent on another edge. (LLM dispatch)

the Path: header line; the authoritative position of a node in the tree (folders mirror it). (AUTHORING §2)

continuity constructed outside a stateless LLM execution through configuration or durable state artifacts. (persistence)

an artifact's relative position within the window at a moment during residency, measured proportionally rather than by a durable token threshold. Placement can change recall efficacy, but its effect is conditional rather than universal. (context flow)

the resident stand-in for an off-window payload; costs its own few tokens always, and carries the signal that triggers paying for the rest. A data pointer (deferred context: follow it, get bytes) or a function pointer (subagent offload: call it, get a return — the agent's name + description, whose contract role is the trigger contract). (cost relocation)

shorthand for an empirically estimated efficient operating region for a stated task distribution, model, context construction, outcome measure, and cost/latency constraint. A revisable evaluation target, not a universal token threshold. (context economy, context efficiency)

a motivation-agnostic substrate that patterns wield rather than apply: LLM dispatch (the parent-child execution edge) and the contract (the seam). (AUTHORING → terms of art)

how many windows an artifact will be billed in: one actor's (a skill body), every actor it's registered with (a description), or every descendant's (inherited context). Required value scales with it — the wider the scope, the higher the admission bar. (context economy)

discard a bad return and re-run fresh; the recovery move native to stateless dispatches, where discarding is cheaper than repairing. (validated seam / re-dispatch)

the fraction of an actor's resident window that is load-bearing for the task at hand; context efficiency's state measure. (context efficiency, context alignment)

admission criterion for the deferral ladder (ruled 2026-08-03): an artifact belongs on the ladder only if its expected fetch value across the skill's serving distribution beats its pointer's standing rent; the losing verdict is scope discipline — cut it. Craft form: if you can't name the session archetype that fetches it, cut it. Applies to any resident surface, data pointer or trigger contract alike. (deferred context)

the span an artifact stays in a window; what statelessness re-bills every remaining turn. (context flow, context economy)

the optional result, status, failure, or artifact pointer sent from a child back to its parent. Its declared shape is the return contract. (contract documentation)

a boundary where data, control, or effects cross between workflow components. Its load-bearing expectations are made explicit and checked only to the rigor the consequence warrants. (the contract)

a named, described body of instructions: one useful packaging and reuse surface for workflow behavior, not the corpus's unit of analysis. (baseline skill)

terse canonical write-ups vs. voiced teaching narrative; a flavor renders its spec subtree and never contradicts it. (AUTHORING)

a pattern nested under another pattern, sharpening it (subagent offload → heavy agent). Not a primitive: it inherits its parent's move. (AUTHORING → terms of art)

machine-written accumulated memory with an explicit writer or concurrency protocol. (durable state)

treat each model invocation as a function of its declared window: retained conversation is logically presented again, and continuity must come from that window, platform-managed reconstruction, or external state—not presumed private mutable memory. Cost face: repeated admission. Feature face: explicit-state dispatches can be disposable and reproducible. (statelessness; cost → context economy, feature → validated seam / re-dispatch)

spec-lane maturity: seeded → drafting → fleshed (the idea is done; claims-freeze) → stable (fleshed + kind-conditional proof obligations), with needs-work as the regression flag. No rung encodes publication readiness. (AUTHORING §6)

a child LLM execution with a distinct context. Its canvas is fresh by default but may include inherited context; a return is optional. (LLM dispatch)

a bounded skill invoked by a parent within the same actor, behind a documented seam. (workflow decomposition)

a distilled preview of a payload, sized and shaped to inform one decision: descend into this / skip it. Its consumer is a decider, not a reasoner. Output of distillation whose declared shape targets a navigation choice; the resident surface progressive disclosure reads at every node of its tree. Its quality — how faithfully it predicts what lies behind it — is its scent (kept informal). (progressive disclosure)

a named output scaffold the agent generates within, rather than from a blank page. (template-constrained generation)

externalized logic and boundaries the agent invokes (CLI / API / MCP / server) rather than contains; shapes how the agent can interact. (externalizing tools & systems)

the description's second job: it tells the model when this fires. (baseline skill)

the finite capacity an actor holds everything in — instructions, descriptions, working material. It fills, it degrades, and everything in it costs. (context economy)

a system in which an LLM makes at least one runtime judgment that materially shapes a later action, artifact, route, or effect. (ADR 0007)

the filesystem actors share; an external channel alongside dispatch and optional return. Every location one actor writes and another reads is a seam with a nonzero write→read gap. (LLM dispatch, contract documentation)