Glossary

One word, one meaning

Each term is defined once, the ISO 1087 way: name the nearest broader concept, then say what distinguishes this one. Find any term below, A to Z.

The scheme has two layers that share one vocabulary. The scheme layer says how content is stored, related and trusted; the lifecycle layer says how work moves from an idea to a validated result. Each entry shows its layer as two small cells — scheme, then lifecycle — filled for the layer it belongs to. Each term takes the hue of the group below that defines it.

The roles hold for any team. An agent’s workspace and budget are a scoped task and a deadline for a person, and a sandbox and a token count for an AI model.

An alternate label stops an agent missing what already exists. An exclusion note stops it filing a question as an idea.

Identity and history

How a thing is named, how its past is kept, and why nothing is ever overwritten: identities, digests, kinds, nodes, versions, sources and the acts that move them.

Native names are kept; only what the system creates is minted. After that, a thing’s past is kept: a version is never edited, and a change is a new record that names what it changed.

Minted identity Both layersAlso ULID · identifier

An identifier the system creates for a thing that has no name of its own: a ULID — 48 bits of millisecond time and 80 random bits — written lowercase in three segments behind a kind code.

≠Not to be confused: Not a sequence number. No central counter exists to race on or to be down, so any tool can mint one anywhere, in parallel — and identities sort by time for free.

#

Native name Lifecycle layer

An identifier a thing already has, unique and stable — a repository’s host/org/name, a package, a term — kept as its identity and qualified by a namespace.

≠Not to be confused: Never replaced by a minted identity. The system mints only what it creates.

#

Handle Both layersAlso short reference

A short reference for readers: a kind code plus the last six characters of an identity, as in stmt-7q4k2m, resolved by a tool from context.

≠Not to be confused: Not a stored reference. Stored references carry the full identity, so they resolve without any index.

#

Digest Both layersAlso content hash · pin

A content address: the SHA-256 of exact bytes. A reference that carries one means exactly that text; the digest a record relied on is its pin.

≠Not to be confused: Not part of what it addresses. A record never contains its own digest, just as a Git object does not contain its own hash.

#

Kind Both layers

A classification fixed for the life of a thing, registered with a short code that leads every identifier of that kind. Every kind is justified by an activity that uses or generates it.

≠Not to be confused: Not a tag that moves. Nothing is promoted: an idea that leads to a requirement stays an idea, and the requirement is a new thing linked back to it.

#

Node Scheme layer

A thing’s permanent identity: one permanent kind, and a pointer to exactly one current version. Only an act moves the pointer.

≠Not to be confused: Not a version. Everyone references the node; what changes is which version it points to.

#

Version Scheme layer

An immutable snapshot of a node’s content and card together, addressed by the digest of both.

≠Not to be confused: Not a revision number on a mutable file. Every earlier version stays retrievable, forever, by its digest.

#

Source Scheme layer

An immutable captured input from outside — a paper, a web page, a chat, a dataset — addressed by the digest of its bytes.

≠Not to be confused: Not a version. A source is evidence the scheme did not author, citable byte for byte whatever is later written about it.

#

Act Scheme layer

The record of one change to a node: what moved, from which version to which, who, when, why, on what grounds, and what it relied on — hash-chained to its parent acts.

≠Not to be confused: Not the lifecycle layer’s event, which records an observation rather than a change.

#

Supersession Lifecycle layer

A record that replaces one version of a thing — a decision, a specification — with another, naming both.

≠Not to be confused: Not an edit. What was superseded stays on record, so every past state remains a query.

#

Records and relations

What is written, and how written things connect: artifacts and activities, the three immutable forms, the four classes of node, cards, and references that point only upward.

The thing being organized is the artifact, never the file. In the lifecycle layer, everything written takes one of three immutable forms — manifest, event, blob — and everything else, including status, is derived from them.

Scheme Scheme layer

The single organizing system for everything a team’s owners, agents and tools do, and the record of it: one way, with no exceptions and no variations.

≠Not to be confused: Not a folder convention. A new kind of content is registered within the scheme and never brings its own mechanism; every exception is counted as debt.

#

Artifact Lifecycle layer

An entity an activity uses or generates — an idea, a question, a decision, a result — whose identity is minted once and is independent of the bytes that carry it.

≠Not to be confused: Not a document or a file. A file, its path and its folder belong to a representation of the artifact, never to the artifact.

#

Activity Lifecycle layer

Work that uses artifacts and generates artifacts, with exactly one actor responsible. It declares the state it requires of its inputs, not a list of them.

≠Not to be confused: Not a box in a flowchart. Activities form a causal graph, on the model of W3C PROV, that may branch, loop and revisit.

#

Record Lifecycle layer

An immutable, content-addressed statement of something that was declared or happened. Records are only ever added.

≠Not to be confused: Not a row that is updated. State is never stored: state(T) is a fold over every record written at or before T.

#

Manifest Lifecycle layer

A record that declares what something is or must become — one that could have been written before the thing occurred.

≠Not to be confused: Not an event, which could not have been written in advance. Briefs, specifications, claims and waivers are manifests.

#

Event Lifecycle layer

A record of an observation — this happened, at this time — that could not have been written in advance.

≠Not to be confused: Not the scheme layer’s act, which records a change to a node rather than an observation.

#

Blob Lifecycle layer

Opaque content too large or noisy to reason over — a transcript, a build log, test output. No rule may conclude anything from its bytes.

≠Not to be confused: Not evidence by itself. Anything a rule uses is first extracted from it, as an event, by a pinned, deterministic parser.

#

Unit Scheme layer

A node of authored content: anything referred to, graded, attacked or replaced on its own. A part of a document is its own unit.

≠Not to be confused: Not a file-sized chunk. Granularity follows use, not formatting.

#

Edge Scheme layer

A node that names a relation — from, to, and why it holds — so the relation itself can be queried, graded, attacked and versioned.

≠Not to be confused: Not a link buried in prose. A relation is first-class, with a kind of its own: depends on, grounded by, related.

#

View Scheme layer

A node holding a declarative query over the graph. Its result is pinned to what it showed, and flagged when it goes stale.

≠Not to be confused: Not a hand-kept list. Every index, outline and table of contents is a view — computed, never maintained.

#

Context Scheme layer

A node holding one task’s working set: the question plus a bounded list of nodes pinned to versions. It widens only by an act.

≠Not to be confused: Not the brief, the sealed contract for a whole unit of work. A context declares attention, and attention becomes auditable.

#

Card Scheme layer

The short, typed, word-budgeted summary of a version that agents read instead of the content.

≠Not to be confused: Not a loose abstract. The card sits inside the version’s digest, so changing it is an act like any other.

#

Staleness Scheme layer

The mechanical flag raised on a record when something it pinned has been superseded.

≠Not to be confused: Not a verdict that the record is wrong — only that what it relied on has moved.

#

Upward reference Both layersAlso part of · child-held reference

A reference held by the child and pointing to its parent, like a foreign key. A parent never lists its children; “what did this produce?” is a query.

≠Not to be confused: Not tidiness. With every reference pinned by digest, a parent that listed its children would be rewritten, with every ancestor to the root, each time a leaf was added.

#

Work and bundles

How a unit of work is handed out and comes back: the brief, the run, the yield and its verdict — and the leases that keep parallel work apart.

Work goes out sealed and comes back signed. Leases, fencing tokens and drift keep parallel work apart and catch a plan that was wrong about what was independent.

Brief Both layersAlso state bundle

The prospective manifest for one unit of work: inputs pinned by digest, scope, budget, a done rule and a cannot-be-done rule — sealed before work starts and addressed by its own digest. The owner accepts it when it branches into more work or is irreversible, frame-extending or intent-bearing; otherwise its issuer accepts it.

≠Not to be confused: Not a passing request. Two briefs that differ only in their timeout are different work, by construction.

#

Run Both layers

One activity executing one brief, recorded by the harness — never by the agent that did the work.

≠Not to be confused: Not a session. Reads and budget are counted per run, so a fresh session resets nothing.

#

Yield Both layersAlso result bundle

The retrospective bundle of a run: one harness-signed manifest enumerating every member by digest, with a count, the verdict and the run’s nonce.

≠Not to be confused: Not a set of separately signed members: a bundle of signed things is not a signed bundle. The nonce stops a yield being replayed as a later run’s result.

#

Verdict Both layers

The outcome a run ends in, each routed to its own recovery: complete, refuse, fail, not understood, blocked — and, in the lifecycle layer, indeterminate and preempted.

≠Not to be confused: Refuse is not fail. “I will not” goes back to the issuer, because the request was wrong; “I could not” is retried only if the cause is non-deterministic.

#

Partition Lifecycle layer

A unit of delegated work with exactly one responsible actor. A child names its issuer; the parent never lists its children.

≠Not to be confused: Not a rung of a hierarchy. Levels are named by relation — issuer, performer, root — never by rank, so the tree can be arbitrarily deep.

#

Leaf Lifecycle layer

A partition light enough to run unattended: measurable, singly assigned, independent, and within its performer’s reach.

≠Not to be confused: Not small by guesswork. Big work is broken down until every leaf passes those four tests, with a deliberate bias toward smaller. A leaf issues no children, so nothing multiplies its errors: its issuer accepts its brief at any depth, unless the brief trips another gate.

#

Lease Lifecycle layer

A time-bounded, exclusive hold on a write region, held by one actor for one partition. It expires by itself, which is the point.

≠Not to be confused: Not a lock someone must remember to release. Its expiry is derived from time, not written by a background process.

#

Fencing token Lifecycle layer

A monotonically increasing number issued with a lease, so a holder whose lease expired cannot still land a late submission.

≠Not to be confused: Not a capability token. It authorizes nothing; it only orders.

#

Drift Lifecycle layer

The derived difference between the dependency graph a plan declared and the one that actually happened.

≠Not to be confused: Not a failure in itself. Drift is how the system catches a plan that was wrong about what was independent.

#

Trust and authority

Who may reach what, and how anyone can tell what really happened: tokens the agent never holds, ranks and compartments, grounds, attestations and acceptances.

Most of this vocabulary exists so that no one has to take an agent’s word for anything. Authority is a token the agent cannot see; evidence is a quote a tool can find in the bytes; a signature proves custody, not correctness.

Harness Both layers

The trusted machinery around an agent: it injects credentials, records runs, signs yields and cuts checkpoints.

≠Not to be confused: Not the agent’s workspace, the scoped place where the work is done. The workspace produces; the harness attests. A workspace holds no signing key, so nothing inside it can sign.

#

Capability token Scheme layer

A per-run bearer token — a Biscuit — injected by the harness at the edge of the agent’s workspace, so the agent never holds it. It can only be narrowed, and every call is checked against it again.

≠Not to be confused: Not a login. OAuth authenticates; the token authorizes. A leaked transcript leaks no credential, because the agent never saw one.

#

Attenuation Scheme layer

The narrowing of a token by adding checks — offline, at any delegation depth, and irreversibly.

≠Not to be confused: Not a policy to remember. “No actor may grant what it does not hold” becomes a property of the token format.

#

Sensitivity rank Scheme layer

A five-step scale of how widely content may be seen — public, shared, private, sensitive, secret — carried on the card and enforced as no read up, no write down.

≠Not to be confused: Not a label taken on trust. A bad or missing rank counts as most sensitive, so a bad label can only hide, never leak.

#

Compartment Scheme layer

An exposure boundary: a set of content safe to hand, in its entirety, to one agent for one task.

≠Not to be confused: Not a topic or a folder. Compartments separate audiences, risks and legal regimes.

#

Grounds Scheme layer

The verifiable evidence an act or output rests on: a harness-captured source or an existing record, plus a verbatim quote a tool can find in its bytes.

≠Not to be confused: Not a plausible citation. A ground that cites something written after the output is refused.

#

Envelope Both layers

The wrapper of grounds every agent output must carry. An output without one that a tool can verify is refused.

≠Not to be confused: Not a signature. The envelope says what an output rests on; an attestation says who held it.

#

Attestation Scheme layer

A signed, timed statement that a named key held these exact bytes.

≠Not to be confused: Custody, never correctness. An attestation proves who held which bytes, not that they were right.

#

Acceptance Both layers

A record of signed, positive assent to one exact version. A brief needs the owner’s acceptance if and only if it is cascading, irreversible, frame-extending or intent-bearing; otherwise its issuer accepts it, at any depth.

≠Not to be confused: Not assurance, which at depth comes from oversight. Silence is refusal, never assent, and acceptance decays: it expires, sooner as consequence rises.

#

Checkpoint Scheme layer

A signed statement of a log’s size and Merkle root, cosigned by a witness, that proves the record only ever grew.

≠Not to be confused: Not a promise. A later log that does not extend a checkpoint fails a consistency proof, as in Certificate Transparency.

#

A gate the agent is asked to respect is not a gate.

Process and weight

How much process work receives and where the owner must step in: gates, weight, discharge, verification against validation, standing rules, claims, waivers and oversight.

A gate sits where a mistake becomes uncorrectable: briefs that branch reach the owner, leaf briefs stay with their issuer, and oversight samples at every depth. Weight has three layers, each keyed on something different. Verifying and validating stay apart: a tool checks the letter, the issuer judges the intent.

Gate Lifecycle layer

A point where the owner must act, placed where a mistake becomes uncorrectable: the act is irreversible, cascading, frame-extending or intent-bearing. A brief cascades when it will be decomposed further — a test computed from the plan.

≠Not to be confused: Not a check on importance, and not an instruction to the agent. A gate the agent is asked to respect is not a gate: the harness enforces it by withholding capability.

#

Weight Lifecycle layer

The amount of process a piece of work receives, in three layers keyed on different things: consequence decides what is produced; size, complexity and competence decide what may be shortened; size, novelty and track record decide how hard it is checked.

≠Not to be confused: Not ceremony scaled to size. Size never reduces what must be produced; it is a reason to be checked harder.

#

Discharge Lifecycle layer

The completion of a step in one line, with its reason.

≠Not to be confused: Not a skip, and not an exemption list. No step is ever skipped; any step may be discharged.

#

Verify Lifecycle layer

A mechanical conformance check: does the result meet the letter of the brief? Performed by a tool, never by the producer.

≠Not to be confused: Not validate. A result can pass every check and still miss the point.

#

Validate Lifecycle layer

A judgement of whether the result meets the intent behind what was written — made by the brief’s issuer, at any depth. Against the original intent, which has no written brief above it, validation always reaches the owner.

≠Not to be confused: Not verify, which checks the letter. Validation checks the purpose.

#

Invariant Lifecycle layerAlso standing rule

A rule that must remain true: it selects subjects by kind, and every later change is checked against it again.

≠Not to be confused: Not a requirement, which is discharged once. A new rule never interrupts running work, but nothing passes a gate without meeting the rules in force when it tries.

#

Claim Lifecycle layer

A manifest asserting that something holds, with its evidence attached and its standing derivable.

≠Not to be confused: Not deleted when wrong. A claim that turned out false stays on record, defeated by a separate record.

#

Waiver Lifecycle layer

A manifest granting a scoped, expiring release of one specific failure.

≠Not to be confused: Never a rule switched off. Every waiver carries an expiry.

#

Reconciler Lifecycle layer

A loop that derives what must be true, derives what is true, and acts on the difference.

≠Not to be confused: Not a trigger. Miss an event and you are permanently wrong; miss a tick and you are merely late. A reconciler that finds no difference writes nothing.

#

Oversight Lifecycle layer

Independent sampling of work at any depth, selected and run outside the chain of delegation that produced it. Assurance at depth comes from oversight, not from acceptance.

≠Not to be confused: Not acceptance: whoever accepts hundreds of briefs accepts none of them carefully (Bainbridge, Ironies of Automation). Oversight is orthogonal to delegation, so an audit never runs through the chain that produced the work.

#

Roles and judgement

Who acts, and which acts are judgements: the three roles of owner, agent and tool, the issuer of a brief, the four verb classes, facts, and the rule for where a decision belongs.

A term tied to one role is set in that role’s type: a tool in mono, an agent in casual, the owner in italic serif.

Actor Lifecycle layer

A party that can be held responsible for an activity, acting in exactly one of three roles: owner, agent or tool.

≠Not to be confused: Not PROV’s agent, which covers all three. A role is not a kind of being: one person can own one piece of work and be an agent on another. And here a tool is a first-class performer, not an implementation detail.

#

Owner Lifecycle layerAlso principal

An actor who holds intent: the person who sets direction, owns the work, says yes at a gate and validates the result against that intent.

≠Not to be confused: Not a reviewer of everything. The owner sees the briefs that branch, not the ones that work, and touches the work at a few fixed points — specify, brief, validate, publish.

#

Issuer Lifecycle layer

An actor — the owner or an agent — that seals a brief for another to perform. At any depth, it accepts a leaf brief and validates the result against the brief.

≠Not to be confused: Not the owner, unless the owner issued the brief. A brief that branches, or is irreversible, frame-extending or intent-bearing, goes to the owner for acceptance whoever issued it.

#

Agent Lifecycle layer

An actor that does judged work rather than a fixed procedure — a person on the team, a contractor or an AI model. It may make judgements; it may never stand in for the owner at a gate.

≠Not to be confused: Not a recorder of its own work. An agent submits; a tool records what it is admitted to say.

#

Tool Both layers

An actor that is software performing a fixed, deterministic procedure — minting, recording, verifying, signing. Software agents reach every tool through MCP, an open protocol for exposing tools to AI agents.

≠Not to be confused: Not a judge. A tool may detect that a judgement is required; it may never make one.

#

Verb class Both layersAlso operation shape

One of four operation shapes, exactly one per command: derive (a pure query), compute (a deterministic production), judge (a judgement), assert (an append).

≠Not to be confused: No command both queries and writes. Assert is the only writer, so everything an agent can affect is a finite list.

#

Role Both layers

What an actor is doing in one act — owning, judging or performing a mechanism — set by the act’s verb class, not by who or what performs it.

≠Not to be confused: Not a kind of being. A person can act as a tool by following a fixed procedure, and an AI model can do organizing work — but its output counts as a tool’s only if it is deterministic and replayable. Otherwise it is a judgement: a choice among declared options, recorded with who answered.

#

Fact Scheme layer

An atom of the rule logic, extracted from written records by a named extractor.

≠Not to be confused: Never written directly. A writable fact base would defeat every gate at once, so the whole fact base can be rebuilt from scratch.

#

Judgement Both layers

A fact produced by the owner or an agent rather than by a rule or a tool — the one place non-determinism enters, so it is fenced, typed and recorded.

≠Not to be confused: Not recorded by whoever made it: the judge submits it, and a tool records it after admission.

#

Lowest-owner rule Lifecycle layer

The rule that a decision is made by the lowest actor whose work covers everything the decision affects. A leaf brief affects only itself, so its issuer accepts it. A brief that branches is multiplied by everything beneath it, and an irreversible act or a rule change affects the whole tree, so they reach the owner.

≠Not to be confused: Not a chain of command. Escalation and delegation are this one rule seen from different places: push down, escalate, or decide.

#

A tool computes which judgements are required, and whether they have been given. It never gives one.