The Algebraהאלגברה

I am going to start this book the way the problem started for me: in the middle of a failure that looked like success.

I run a print farm — eight 3D printers, live telemetry, registered inventory, typed workflows. For years I have been building the substrate that would let software agents manage it. The plumbing works. I can watch every printer from a dashboard, track every job, and replay what happened on any given morning.

And yet as I write this, my agents are still not allowed to press Print unattended.

Not because the code is broken. Not because I don't trust the hardware.

They are not allowed to act on their own authority because I could not yet answer one question to my own satisfaction: what gave that action the right to happen?

That question is what this book is about. Everything else follows from taking it seriously.

The failure that made the question unavoidable

Earlier this year, the system that runs my farm told me — with complete confidence — that nine of my ten products were single-color prints.

It was wrong about all nine.

Nothing crashed. No error fired. The detection logic checked which extruders each design file used, found one, and produced a clean, confident label: single color. It never looked at the painted-face data or the color-penetration metadata sitting in the same file.

A false claim entered the system with the same authority as a true one. Scheduling assumptions had already started leaning on it.

Single-color jobs can run on any printer in the farm. Multicolor jobs queue behind one machine.

Wrong claim, wrong plan.

The architecture failed — quietly, politely, at full confidence.

What is worth pausing on is what the failure did not look like. There was no model, no language model in that path. There was no hallucination, no ambiguity, no prompt engineering to blame. The detection logic was well-defined, correctly implemented, and deterministic. It just read one signal when three were required.

The problem was not intelligence. It was architecture. And that distinction matters, because adding a smarter model to a broken architecture does not fix the architecture — it gives the architecture a more convincing voice.

What the alternative actually is

Across the industry, the standard response to this kind of failure is more orchestration: retrieve more context, put a better model in the middle, add a tool call, add a check. Most "agent" systems are this: a retrieve step, a classify step, a route step, a call step, strung together with prompts and function calls.

I do not want to dismiss this approach. For many tasks, it is exactly right. If your agent answers low-stakes questions and the worst outcome is a correction, this architecture is fine. Ship it.

But the moment an action moves money, schedules a machine, commits an appointment, or touches a customer — the moment a wrong step stops being data and starts being a consequence — a different question enters the room.

Not "did the model get it right?"

But "what gave that action the right to happen?"

Most orchestration stacks cannot answer this question. They can tell you what the model concluded and which function was called. They cannot tell you what the evidence was, how much of it there was, whether it was fresh, under which purpose the system was reasoning, and whether the confidence level was sufficient for this action specifically — as opposed to logging it, or flagging it for review, or simply recording that it happened.

There is no typed path from observation to action. There is a sequence of calls, and at the end of the sequence, something happens. That is not accountability. It is execution.

The thing that is missing: a typed path

The gap is not hard to state.

Between a raw event and a warranted action, several things have to happen. Something happens — a message arrives, a sensor fires, a file changes. That event is about something: a particular entity, registered in the system. The evidence is assembled in context: not a retrieval dump, but a structured account of which facts belong together, for this entity, at this moment. The system interprets the assembled evidence under a declared purpose, because the same evidence means different things depending on what the system is trying to do. It arrives at a conclusion with a confidence score — not a certainty, but a computed estimate of how well the evidence supports the claim. And that confidence clears the threshold for this specific action — because the bar for logging is not the bar for dispatching, and the bar for dispatching is not the bar for sending.

Only then should an action happen.

Most systems have none of this. They have "retrieve," "classify," and "call." The middle is a black box, and the output of the black box drives an action.

Here is the structural consequence: if something goes wrong, you cannot audit it. You can look at the prompt. You can look at the output. You cannot reconstruct the evidential chain, because no evidential chain was built. There was only the output, and the call it triggered.

This is the problem.

It is not that the models are bad. It is that the models are doing reasoning that the architecture never designed a place for — and then acting on the result with no record of the reasoning itself.

Why the answer is an algebra

The solution is not more orchestration. It is structure.

What the chain from event to action needs is the same thing any well-defined computation needs: typed objects, composable operators, and rules that hold across the composition. If a step receives typed input and produces typed output, and the types constrain what can follow, then the whole chain composes — and composition means you can trace it, audit it, and ask why at any point.

An algebra, in the technical sense, is exactly this: a closed set of operators that act on typed objects and compose under fixed rules. Relational databases have one — a handful of operators that take tables and return tables, nothing ever escaping the type. That closure is why a query planner can reason about a query before executing it, and why the path of computation can be inspected instead of guessed.

Most agent systems have no such closure. The output of one step is whatever the model emitted; the input of the next is whatever you can coerce that into. There is no rule that the pieces compose, because there are no typed pieces and no operators.

The opposite of an algebra is glue.

This book describes an alternative: an algebra for agent systems, with twelve typed spaces — entity, purpose, event, raw data, evidence, claim, context, feature, meaning, signal, aggregated meaning, action — and nine algebraic operators that move between them. Everything else is boundary plumbing or implementation machinery — perception at the intake boundary, loaders, adapters, dispatch scaffolding. None of those are operators; they carry data to the algebra's edge and away from it. The reasoning is inside; everything else is around it.

Later chapters will make the stronger claim: that this algebra is specified, proved, and implemented. This chapter only establishes why such a structure is needed. This volume presents all three — the specification in Parts II and III, the mathematical proof spine in Part IV, and the implementation receipts in Part V.

What this chapter is not claiming

One clarification before the algebra begins.

The claim is not that all agent systems need this. They do not.

The claim is also not that this algebra is the only possible answer to the problem it solves. It may not be.

The claim is narrower and, I believe, defensible: if you want to build an agent system that can tell you — at any point, for any action — what gave that action the right to happen, you need typed spaces, composable operators, and provenance that survives the composition. The specific algebra in this book is one worked-out answer to that requirement. It has been implemented and run against real problems. The proof spine is canonical. The receipts exist.

The question "what gave that action the right to happen?" does not go away.

Either you build something that can answer it, or you build something that cannot — and hope the cases where it matters never arrive.

The rest of this book

Part I introduces the motivation and the structure: why the algebra exists, what the four-line thesis means, and how twelve spaces and five planes carve the problem.

Parts II and III walk the algebra itself: each space, each operator, the failure and control semantics, the purpose-isolation guarantee, and trace.

Part IV presents the mathematical proof spine: the axioms, the lemmas, and the first theorem suite, with full proof skeletons in the appendix.

Part V gives the implementation receipts: the reference implementation CsaCore, and its two domain bindings.

Part VI closes the loop between the public essays that drafted this material and the book you are reading — and names what this volume does not yet do.

The next step is to name the four movements hidden inside that question: bit, context, purpose, action. That is Chapter 2.

The algebra is the chain.

This book is the audit trail.

There is a sentence near the beginning of the Spaces document — the canonical reference for the algebra — that I have read more times than any other in this project:

A raw event is a bit. Context gives it direction. Purpose gives it meaning. Confidence gives it the right to drive action.

Four lines. The whole architecture is already in them.

But a sentence that short either becomes a slogan or becomes a commitment. The difference is whether you can show the gap that exists before each transformation — the cost of skipping it, the shape of the failure when it is skipped.

This chapter earns the sentence. One line at a time.

A raw event is a bit

On one evening in early June, my printer sent 1,422 messages to my logger.

1,212 of them reported the Wi-Fi signal strength. Twenty contained the field that says whether anything was actually printing. One thousand four hundred and two of them had nothing to say about the print state at all.

Every single one was true. Every one was recorded faithfully, permanently, with full provenance.

And not one of them, by itself, meant anything.

Here is another message from the same evening:

{"print": {"nozzle_temper": 219.96875}}

Nozzle temperature: 219.96875 degrees Celsius. Is that good news or bad news?

If the printer is mid-print with PLA filament: perfect. That is the target temperature, holding steady. Good news.

If it is supposed to be idle: something is wrong. The heater is on when it should not be. Bad news.

If the print job finished an hour ago and nobody commanded a cooldown: ambiguous, edging toward bad, and a question about what else in the system has lost track of time.

Same number. Three opposite readings. The number carries none of them.

The same problem appears everywhere the moment you look for it. A webhook fires. A database row changes. A sensor trips. A customer replies: "ok."

"ok" is my favorite.

It is true, timestamped, faithfully recorded — and it means nothing until you know what it is answering. "ok" to a refund offer and "ok" to a cancellation warning are the same bit. One is a resolution; the other is an escalation risk. The event does not say which.

The meaning was never in the event.

A raw event is a first disturbance in the system. It says: something happened. It does not say what the something means, whether it matters, or what should follow. Before anything else can be said about it, it needs to pass through three more transformations — each of which has a gate, and each of which can fail.

Context gives it direction

Return to the nozzle reading.

The number is the same. What changes the reading is everything that surrounds it: which printer sent it, what the printer was supposed to be doing at the time, what job was running, what state the agent last recorded for it, what time it is relative to the last acknowledged command.

That surrounding information is context.

Context is not metadata. Metadata is a label attached to an event at the source. Context is assembled — from entity state, time, relationships, prior evidence, and the current situation — at the moment the event arrives. Purpose enters next: it decides what kind of meaning this context is allowed to support. Two events with identical payload can carry opposite context because the entity states that receive them are different.

The nozzle reading from a printer mid-print in a monitored job has one context. The same reading from a printer that has not moved in four hours has a different context entirely. The bit did not change. The direction it points changed because the frame that holds it changed.

This is why context cannot be inferred from the event alone. The event is an input to the pipeline. Context is the ground on which the pipeline stands. Without it, direction is undefined: the algebra has no orientation, the operators have nothing to act relative to.

Context is the first gate. Before a bit can mean something directional, the system has to have assembled a coherent account of the entity it is about, the situation that entity is in, and the moment in which the event arrives. An agent that skips this gate and proceeds to meaning is projecting, not interpreting.

Purpose gives it meaning

Suppose context has been assembled. The entity is known, the situation is clear, the event has direction. That is still not meaning.

Consider a temperature signal from a correctly identified printer in a correctly assembled context. A manufacturing system sees that signal and reads: the job is on track, no intervention needed. A maintenance system looking at the same signal reads: this printer is running at the high end of its thermal envelope for this filament type — flag for inspection before the next long run. A cost-management system reads: heater hours are accumulating on the scheduled plan.

Same signal. Same entity. Same context. Three different meanings.

The difference is not in the data. It is in what each system is trying to do — in the purpose that frames the observation.

This is principle four from the Spaces document: No meaning without purpose. The same signal can become different meanings depending on the agent's purpose. Purpose is not a parameter of meaning — it is part of meaning's definition.

An agent that computes "hot lead" without specifying which purpose framed that computation has produced a number with no definition. Sales sees intent; Support sees urgency; Security sees anomaly — and all three are reading the same underlying signal. The meaning is not in the signal. It is in the intersection of the signal and the purpose frame.

This is why the algebra is purpose-indexed throughout. Later chapters will formalize this: there is no single meaning space — there is a family of meaning spaces, one per purpose, and meaning vectors are not comparable across purposes without an authorized transport operation. That operation exists, but it is not free and not automatic. The purpose boundary is load-bearing.

An agent that crosses purpose boundaries without authorization is not producing meaning. It is borrowing a number from a frame where it was valid and using it in a frame where it is undefined. The number may look right. The computation downstream will be wrong in ways that are very difficult to detect, because the error is structural rather than numeric.

Confidence gives it the right to drive action

Now suppose all three transformations have happened. The event has direction. The purpose is clear. A meaning vector has been computed. The agent could act.

Should it?

The answer depends on what has been accumulated before this moment. A single temperature reading, even a well-contextualized one, does not establish a reliable claim about a printer. A pattern of readings across a window, interpreted consistently, under a purpose frame that has been active long enough to have calibrated expectations — that starts to build a claim. Confidence is not a property of a single signal. It is a property of the evidence base.

The discipline I am building with Algentis holds to one rule here: confidence must be earned before it authorizes action. An agent that acts on a single reading has promoted a bit to a belief in one step, and that is exactly the failure that the nine-products incident demonstrated in Chapter 1. The system saw one field — a true field, faithfully recorded — and turned it into a decision. No confidence test. No threshold. No accumulated evidence.

The right to drive action is not a consequence of meaning having been computed. It is a separate gate, grounded in how much evidence the system has accumulated, how consistent that evidence has been, and whether the confidence in the current meaning vector meets the threshold required by the action being considered.

This is not conservatism for its own sake. It is the recognition that actions have consequences that observations do not. An observation that turns out to be wrong costs nothing except a correction. An action taken on an insufficiently confident claim can trigger a cascade — in a print farm, a cancelled job; in a CRM, a customer contact that should not have happened; in a healthcare system, something that cannot be undone.

The confidence gate is the last point at which the algebra can stop and ask whether it knows enough. After action, the question is no longer whether to act — it is what to do about having acted.

Four gates, one chain

The four lines are four gates, in order.

The bit must exist — something must have happened, faithfully recorded, at a known time, from a known source.

The bit must be oriented — context must be assembled from entity state, time, relationships, prior evidence, and the current situation, before direction can be assigned.

The orientation must be purposeful — the meaning computation must be relative to a declared purpose, not borrowed from another frame.

The meaning must be confident enough — evidence must have accumulated to the threshold that the intended action requires.

Skip any gate and the chain breaks. The break may not be visible immediately. A system that acts on uncontextualized events will produce output that looks like meaning. A system that borrows meaning across purpose frames will produce numbers that look like results. A system that acts before confidence is sufficient will produce decisions that occasionally turn out to be correct — which is worse than consistently wrong, because it makes the structural failure invisible until the stakes are high enough to expose it.

The four-line thesis is not a description of a happy path. It is a description of the minimum that must happen before an agent is allowed to claim that it understood something.

Chapter 3 will give these four lines their formal shape: twelve spaces, five planes, and the algebraic operators that move between them. The words — bit, context, purpose, action — are already precise. What follows is the machinery that makes the precision operational.

{"print": {"nozzle_temper": 219.96875}}

Planes organize. Spaces contain. Subspaces decompose. Objects inhabit. Operations transform. Runtime orders. Axioms govern.

Seven verbs. That is the whole architecture.

The Spaces document states them in this exact form, at the end of the section on structural hierarchy, after working up to them through two sections of definitions. I could not have written that sentence on the first day I designed the algebra. I could only write it after I had built it once, dismantled it, rebuilt it, and then had to explain it to someone who was not going to build it.

That attempt at explanation is where this chapter begins.

The problem with twelve spaces

The first time I tried to explain the framework to someone outside the project, I listed the spaces.

Entity. Purpose. Event. Raw Data. Evidence. Claim. Context. Feature. Meaning. Signal. Aggregated Meaning. Action. Twelve. I listed them in order, named each one, gave each a sentence. By the time I reached Claim the other person had lost track of what Event was for. By Meaning they had lost Context entirely. By the time I reached Action the framework looked like a taxonomy, not an architecture — and taxonomies are things you look up, not things you reason with.

The cognitive load was wrong. Twelve is too many to hold in working memory without a scaffold.

The scaffold is the planes.

Spaces are the primitives; planes are the architecture

The framework distinguishes these two levels carefully, because the confusion between them is responsible for most of the early difficulties anyone has with the algebra.

Spaces are the primitives — the twelve typed sets the algebra actually operates on. Each one is a set of typed objects: entities, events, claims, signals, meaning vectors, actions. Each has its own formal structure, its own membership conditions, and its own role in the pipeline. When the algebra does something — interprets an event, produces a signal, selects an action — it is operating on the objects that inhabit these spaces.

Planes are the architecture — five groupings that organize spaces by the cognitive role they play. They do not add new objects or new operations. They add legibility. A plane answers one question an agent must answer at runtime, and it groups together all the spaces that participate in answering that question.

The relationship is fixed: spaces are the primitives; planes are the structure that makes them navigable. An agent never operates "in a plane." It operates on spaces. The planes are for the human reader — and for the system designer who needs to reason about which spaces depend on which others, and why.

Five planes are easy to hold in working memory. Each one maps to a question anyone can ask of an agent: what are you reasoning about? what did you observe? what can you infer? what does it mean? what are you going to do?

The five planes

Grounding — About what, and for what purpose?

Before an agent can observe or infer or act, it has to know two things: what entity it is reasoning about, and what purpose is framing the reasoning. The Grounding plane contains the three spaces that establish this foundation: Entity (X), Purpose (P), and Context (C).

Entity is the identified subject — the thing the agent is tracking. Purpose is the interpretive frame that determines what kind of meaning is relevant. Context is the assembled ground on which every subsequent interpretation stands: the entity's current state, history, relationships, trust profile, and the active constraints of the purpose.

Without grounding, an agent is producing signals that are not about anything in particular, under no declared purpose, with no assembled context. The output may look like meaning. It is noise with structure.

Observation — What happened, and what do we have?

Observation captures what arrived at the boundary and what has been collected from it. The three spaces here are Event (E), Raw Data (D), and Evidence (I).

An event is a raw arrival — a bit, in the sense Chapter 2 used. Raw data is the structured material associated with that event: the payload, the reading, the record. Evidence is what has been selected and retained as relevant to the current purpose — not everything that arrived, but what was admitted through the boundary as worth reasoning about.

The distinction between raw data and evidence is not cosmetic. A system that treats everything that arrives as evidence has no admission discipline. Evidence requires an admission discipline, and that discipline has consequences for everything that follows.

Interpretation — What can we infer?

Interpretation turns observation into assertions and computable handles. Two spaces: Claim (K) and Feature (F).

A claim is a typed interpretive assertion — a structured statement about an entity that goes beyond the raw event and says something about what the event means. A feature is a structured, computable projection of the context that can be operated on by the meaning operators. Both are the output of reasoning, not observation; both carry the provenance of the evidence that produced them.

Meaning — What does this point to, in what direction, with what strength?

Three spaces: Meaning (M), Signal (Z), and Aggregated Meaning (m). The meaning operators produce local meaning vectors from interpreted events within context; signals bundle those vectors with entity, provenance, confidence, and purpose; aggregation combines many signals into a single action-ready meaning object.

This is where the algebra does the work that replaces heuristic scoring. Meaning is not a label or a score. It is a structured vector, produced by typed operations, with a traceable provenance chain and a declared confidence.

Action — What should we do?

One space: Action (A). The action operator takes a grounded, action-ready meaning object — the output of aggregation, carrying entity, purpose, accumulated meaning, confidence, and provenance — and produces an action when the confidence threshold is met and the action is authorized under the active purpose. When the threshold is not met, or the action is not authorized, the result is not nothing: it is a structured control outcome that the rest of the system can reason about.

Two orderings that must not be confused

Here is the thing about the planes that confused me longest, and that confuses almost everyone who encounters the framework for the first time.

The planes describe what each space is for. The runtime flow describes when each space becomes available.

Those are not the same ordering. And the difference matters.

Context is in the Grounding plane — it is grounding work, the work of anchoring every downstream interpretation to a stable ground. That is what Context is for. But Context cannot be assembled at the start of the runtime sequence. To assemble a full context, the agent needs the entity's current state, its recent history, evidence-quality assessments, claim-level information. Those things come from Observation and Interpretation. You cannot have them before the agent has observed anything.

So the runtime sequence does not move cleanly from one plane to the next in plane order. It moves like this:

Grounding         X and P established — entity identified, purpose declared
      ↓
Observation       E → D → I — events arrive, data is collected, evidence is admitted
      ↓
Interpretation    K formed from I — claims produced from evidence
      ↓
Grounding         C assembled — context built from entity, purpose, claims, time, relationships, trust
      ↓
Interpretation    F computed within C — features computed inside the assembled context
      ↓
Meaning           local meaning → signal → aggregated meaning
      ↓
Action            grounded meaning translated into action or structured control outcome

Grounding appears twice. Interpretation is split. This is not a flaw — it is a structural feature of any system that has to be grounded before it can be fully informed.

The plane tells you the cognitive kind of work a space does. The runtime order tells you the sequence in which that work becomes possible. The planes do not prescribe the sequence; the dependencies do.

This distinction — ontological membership versus procedural order — is one of the load-bearing design decisions of the algebra. Getting it wrong produces frameworks that either constrain runtime unnecessarily (insisting that all grounding happen before any observation) or lose legibility entirely (treating the runtime sequence as the only organizing principle).

The seven structural concepts

With spaces, planes, and runtime order established, there are four more concepts in the structural hierarchy before we reach the algebra itself.

Subspaces are the internal anatomy of a space. Context is the clearest example: it is not a flat set but a structured composite, with eight named components (identity, state, history, time, relationships, trust, constraints, purpose). Other spaces have internal structure too — the Meaning space is purpose-indexed, which is why there is a family of meaning spaces rather than a single one. Subspaces are where the framework gets fine-grained without losing the clarity of the top-level picture.

Objects are the typed elements that inhabit spaces and carry content through the system — entities, events, claims, signals, meaning vectors, actions. They are what the operations transform. An object without a space has no defined type. A space without objects is an empty set with no content.

Operations are the nine algebraic moves that transform objects from one space into objects in another — interpretation, signalization, aggregation, action selection, purpose-bounded transport, and others. Later chapters will define them. Here, the point is the count: nine, not arbitrary. Everything that moves data between spaces moves it through one of these nine operations. Everything outside them is boundary machinery, not algebra.

Axioms are the laws that govern which operations and compositions are valid. They are what makes the algebra an algebra rather than a collection of procedures. Part III will work through them. Here, the point is that they exist and that they are what gives the framework its closure property — the property that lets a system reason about its own computation before executing it.

The seven concepts together:

Planes organize. Spaces contain. Subspaces decompose. Objects inhabit. Operations transform. Runtime orders. Axioms govern.

When the reader reaches the end of Volume 1, each of those verbs will have a chapter or section behind it. This chapter was the map. Part II is the terrain.

The twelve spaces: a reference table

Space	Symbol	Plane	One-line role
Entity	X	Grounding	The identified subject the agent reasons about
Purpose	P	Grounding	The interpretive frame that governs what meaning is relevant
Context	C	Grounding	The assembled ground: state, history, relationships, trust, constraints
Event	E	Observation	A raw arrival at the boundary — something happened
Raw Data	D	Observation	The structured payload associated with an event
Evidence	I	Observation	What was admitted from raw data as worth reasoning about
Claim	K	Interpretation	A typed interpretive assertion about an entity, derived from evidence
Feature	F	Interpretation	A structured, computable projection of context for the meaning operators
Meaning	M	Meaning	A directional meaning vector produced within a purpose-indexed subspace
Signal	Z	Meaning	A meaning vector bundled with entity, event, confidence, provenance, purpose, context
Aggregated Meaning	m	Meaning	The result of aggregating many signals into an action-ready meaning object
Action	A	Action	A world-affecting decision produced when grounded meaning meets threshold and authorization

This table is the legend. Each row becomes part of the terrain of Part II. The chapters that follow deepen these spaces in their plane groupings — some spaces receive chapter-level treatment on their own; others are paired because their roles are only clear in relation to each other. By the end of Part II, every cell will have a formal definition, a worked example, and a clear account of what goes wrong when that space is missing or conflated with a neighbor.

Grounding         X ו־P נקבעים — ישות מזוהה, תכלית מוצהרת
      ↓
Observation       E → D → I — אירועים מגיעים, נתונים נאספים, ראיות מתקבלות
      ↓
Interpretation    K נוצר מתוך I — טענות מיוצרות מראיות
      ↓
Grounding         C מורכב — הקשר נבנה מישות, תכלית, טענות, זמן, יחסים, אמון
      ↓
Interpretation    F מחושב בתוך C — מאפיינים מחושבים בתוך ההקשר המורכב
      ↓
Meaning           משמעות מקומית → אות → משמעות מצטברת
      ↓
Action            משמעות מקורקעת מתורגמת לפעולה או לתוצאת בקרה מובנית

Here is the kind of failure the Grounding plane is designed to prevent.

An evaluation agent runs on the same printer twice in two days. Its job: decide whether the current print job is proceeding normally. On day one it rates the printer low-risk. On day two — same printer, same class of job — it rates it high-attention.

The data is the same. The printer has not changed. The events are comparable. The error is not in the data.

The purpose had drifted by one version between runs. A policy update between the two runs had shifted Ω_p — the constraints and weightings that govern what counts as normal — by enough to produce a different reading of the same evidence. The agent was not broken. It was operating under two different interpretive frames and producing two different interpretations of the same facts. Both were correct under their respective frames. Neither was labeled as such.

The lesson is not "don't update policies." The lesson is that the frame is part of the output. If the frame is not visible and versioned in the result, the result is not interpretable by anyone who was not present when it was produced.

This is the problem that the Grounding plane exists to solve.

What grounding is for

Grounding is the part of the algebra that prevents meaning from floating. It binds every pipeline run to three things before interpretation can begin: who or what the run is about, what the run is trying to determine, and the assembled situational ground against which evidence is interpreted.

Strip any one of the three and the consequences cascade silently. Strip the entity and the pipeline is reasoning about nothing — all its claims are typologically correct but referentially empty. Strip the purpose and the pipeline has no meaning space to operate in — M_p is undefined, so no interpretation operator has a frame to produce into. Strip the context and the pipeline has a subject and a frame but no ground — signals are produced but they float, untethered from state, history, relationships, and the constraints the purpose imposes.

The three spaces of the Grounding plane — Entity (X), Purpose (P), and Context (C) — answer the single question that every agent must be able to answer before its conclusions mean anything: about what, and for what purpose, and in what situation?

They answer it together. None of the three is sufficient alone.

Entity: fix the subject

The Entity space X is, at its simplest, the set of things the agent is permitted to reason about. Entities are identified subjects — not records, not scores, not events, not categories. An entity is the thing that two records from different systems can both point to, and still be pointing to the same one thing.

The distinction matters because most systems treat records as subjects. If a Salesforce lead record and a Stripe customer record both point to the same company, a record-centric system may reason about them as two separate subjects — and produce two separate sets of conclusions, potentially contradicting each other, with no mechanism to detect the contradiction. A system that resolves them to the same entity (x ∈ X) can produce one coherent set of conclusions, with both records contributing evidence.

The framework's first axiom — no meaning without identity — is, precisely, the statement that no operation in any later space is well-defined when its entity argument is null or unresolved. There is no such thing as a well-formed claim without a subject. There is no such thing as a signal without a target. There is no such thing as an action without a recipient. Identity is the precondition for all of it.

The failure mode is concrete. In the issue that forms the spine of newsletter #4, I typed one character wrong on a printer's serial number during onboarding. The broker accepted the connection. But every subscription to that printer's telemetry was silently killed, because the serial number I had entered did not match any registered device. For two hours, the signals I was receiving were about a printer that did not exist in X.

The failure was not loud. There was no error message saying "unresolved entity." There was a category of symptoms that all looked like configuration problems, firmware problems, authentication problems — every one of them pointing somewhere other than the actual cause. When identity is wrong, every error lies. The failure of X does not announce itself as a failure of X. It announces itself as a failure of whatever space the pipeline touched next, because the object it passed to that space had no valid referent.

Three things must be true for something to belong in X: it must have referential identity (a clear sense in which "the same one" can be re-encountered); it must carry grounding attributes (facts stable within the agent's operational horizon); and it must be operationally referred to by the agent. Anything that fails one of these tests — a computed score, a category, an event label, a state value — does not belong in X, regardless of how convenient it would be to treat it as an entity.

Purpose: bind frame and warrant

The Purpose space P is the interpretive frame. It is the answer to the second half of the Grounding question: for what purpose?

Here is the example the Spaces document uses, and it is the right one. A sales agent and a support agent and a security agent may all be watching the same entity at the same time. A customer who visits the pricing page is, under the sales frame, showing high intent — a positive signal. Under the customer success frame, the same visit signals comparison-shopping or confusion — a different, more ambiguous reading. Under a security frame, if the visit is anomalous in timing or pattern, it might signal a compromised account.

Same entity. Same event. Three opposite interpretations. The difference is not in the data. It is entirely in the purpose that frames the interpretation.

This is what the Spaces document means by the sentence that drives Chapter 2 and returns here in its formal form: Purpose is not merely a parameter of meaning — it is part of meaning's definition. A meaning vector produced under Sales is not the same type of object as a meaning vector produced under Security, even if they were both computed from the same event about the same entity. They live in different purpose-conditioned subspaces of M, and they are not directly comparable.

The algebra's parallel statement: no interpretation without purpose. No operation on any downstream space is valid without a resolved p — because every interpretation operator takes p as a required argument, and without p, the meaning space M_p is undefined.

But purpose is more than a meaning-space selector. The formal structure of a purpose p has five components: an identifier, a version, the meaning-space basis M_p, a weighting function W_p, and a policy structure Ω_p.

Ω_p is the one that carries the most weight in practice. It is the constraints and policies active under this purpose — what actions are permitted, what evidence quality is required, which entities are in scope, and what feedback loops are wired. This is what I mean when I say that purpose binds frame and warrant. The frame (M_p, W_p) determines what the signals mean. The warrant (Ω_p) determines what the agent is authorized to do with them.

An agent that has a frame but no warrant can produce meanings with no authorized consequence. An agent that has a warrant but no frame is producing policy-compliant noise. The two are not separable: the purpose brings both together, and both are declared upfront, versioned, and enforced throughout the run.

This is also why the version matters. The policy shift that caused the two-day disagreement in the opening of this chapter was a version change to Ω_p. The version component ν(p) of a purpose is what allows audit and replay to reconstruct not just what the agent concluded, but under what exact frame and warrant it concluded it. Without versioning, two runs that look identical in their inputs but differ in their outputs have no auditable explanation.

Context: assemble the ground

The Context space C is the assembled situational ground. It is the most structurally complex of the three Grounding spaces because it cannot be populated at the start of a run — it is built mid-pipeline, from the products of Observation and Interpretation.

Context is the composite. In compact notation, the context object has this shape:

C(x, t, p) = ⟨id(x), S(x, t), H(x, t), τ(t), R(x, t), Q(x, t), Ω_p, p⟩

Eight components: the resolved identity, the entity's current state (its current claims, as understood by the agent), its relevant history, the temporal frame, its relationships network, a trust profile, the purpose's policy constraints, and the active purpose itself.

Chapter 3 explained why context belongs to the Grounding plane but is assembled after Observation and Interpretation have run: most of its components — state, history, trust — require claims to have been produced before they can be populated. You cannot know what state the entity is in without having observed it and made claims about it. The agent re-enters Grounding mid-pipeline to assemble C once those claims exist.

Chapter 2 illustrated why context cannot be inferred from the event. The nozzle temperature reading meant one thing in the context of a running job and another thing in the context of an idle printer that should have cooled hours ago. The number was the same. The context was not. Context is what turns direction from ambiguous into signed.

What Chapter 2 did not say, and what belongs here, is that context is also what makes claims about an entity rather than about a reading. A claim that "the nozzle temperature is 220 degrees" is a reading. A claim that "the printer is mid-print with PLA at target temperature" is a claim about the entity, in the context of its current state (S(x, t) includes the active job), its history (has this printer been running continuously for the expected time?), and the purpose's expectations (Ω_p includes what "normal mid-print" means for this entity type under this purpose).

That is the gap that context fills. Without S(x, t), the claim cannot be grounded in current state. Without H(x, t), it cannot be placed in a pattern. Without Q(x, t), it cannot be weighted by how much the agent should trust the sources that produced it. Without Ω_p, it cannot be evaluated against what the active purpose considers normal.

Context does not just surround the interpretation. It is the material the interpretation is about. A signal produced without an assembled context is a reading attached to an entity address, not a meaning produced within a situational frame.

The three together

X, P, and C answer the Grounding question jointly. None of the three is sufficient alone.

Entity without purpose gives the agent a subject but no frame. It can receive events about that entity and record them. It cannot interpret them, because interpretation requires a meaning space, and a meaning space requires a purpose. An agent that interprets without purpose is borrowing a frame it never declared — and borrowing a frame it never declared means that nothing it concludes is auditable, because there is no record of what the interpretive conditions were.

Purpose without entity gives the agent a frame but no subject. The meaning space is defined, the weights are set, the policies are in place. But every operation that takes an entity argument has no valid input — and that is every operation in every downstream space. Claims, signals, meaning vectors, and actions are all entity-parameterized. Without a resolved entity, in the algebra this is a halt condition — no downstream operation is valid. In systems that fail to enforce the entity gate, the same defect appears as a silent cascade: claims attach to null subjects, signals target no valid entity, and actions arrive at no legitimate recipient.

Entity and purpose without context give the agent a subject and a frame, but no ground. Interpretation can begin, because the meaning space is defined and the subject exists. But the claims it produces will be claims about the event in isolation, not claims about the entity in its situation. Signals will be produced, but they will not be grounded in state, history, or relationships. The pattern that makes a temperature reading meaningful — knowing what the entity was doing, what it normally does, what has changed — lives in context. Without context, every reading is evaluated in a vacuum.

Grounding is not a phase to be completed and left behind. It is a condition that must hold throughout the run. Context is re-assembled as new evidence arrives. Purpose may shift between runs as policies and selection logic are updated, but within a run the selected purpose must remain fixed and versioned. Entity identity must be maintained against incoming events that may add to or challenge the current record map. The Grounding plane is always active, even when the pipeline is in Observation or Interpretation. This is what the Spaces document means when it says Grounding is re-entered, not left behind.

The three failure cascades

Each space in the Grounding plane has a characteristic failure mode, and each produces a distinct kind of downstream damage.

Unresolved entity — nothing attaches. Claims are asserted about a null subject. Signals are emitted with no valid target entity. Actions arrive at no recipient. The cascade is silent: the pipeline may complete without errors, because the type system allows null entity references in some implementations, but every output is referentially empty. The correct response is not to produce degraded output — it is to halt the downstream pipeline for this observation and surface the identity resolution failure explicitly.

Unselected purpose — meaning space is undefined. The interpretation operator η has no M_p to project into, no W_p to weight with, no Ω_p to enforce. Nothing downstream of Grounding can proceed without a resolved purpose. The cascade here is not silent: any operation that takes p as a required argument will fail. The correct response is to halt before interpretation begins, not to continue with a default or inherited purpose that was not explicitly declared for this run.

Missing context — signals float. The entity and purpose are resolved, so interpretation can begin — but the claims it produces are claims without ground. A temperature reading becomes "220 degrees" rather than "target temperature for a running PLA job, consistent with the entity's three-hour runtime history and within the tolerance Ω_p defines as normal." Everything downstream is technically well-formed but situationally shallow. This failure is the hardest to detect, because the output looks like meaning. It is meaning without anchor.

The chapter that follows — Chapter 5 — begins at the moment Grounding is complete. Entity is resolved, purpose is declared, and the first components of context are in place. The pipeline is ready to observe.

Here is the distinction that most implementations collapse and the algebra insists on holding.

Imagine a temperature sensor on one of the farm's printers sending a reading every sixty seconds. Over a twenty-four-hour period that is 1,440 readings. They arrive. The broker receives them. The raw data accumulates. Every reading is available.

If the printer entity is not resolved — if the device's identifier cannot be matched against a registered entity in X — none of those 1,440 readings can be admitted as evidence. Not because the algebra failed to receive them. Not because the readings were wrong. Because evidence is not material that arrived; evidence is material that was admitted under a grounding frame.

The Observation plane exists to enforce that distinction. Its three spaces — Event (E), Raw Data (D), and Evidence (I) — answer the same observation question at three levels of commitment. E says what happened. D says what the agent has in reserve. I says what the agent has selected as worth reasoning about.

None of the three is sufficient alone. Together they implement the algebra's first downstream constraint after Grounding. Call this the observation-plane discipline: no evidence without grounding.

The observation plane

The Observation plane sits between Grounding and Interpretation in the algebra's structural map. Chapter 3 identified its members — E, D, I — as the spaces through which the agent perceives and selects. Chapter 4 established the grounding conditions that must hold before interpretation can begin. Observation is where those conditions first become gates.

There is a structural asymmetry at the heart of the plane that the algebra makes precise. Events arrive at the agent's boundary regardless of whether Grounding is resolved. Raw data accumulates whether or not any purpose is active. But evidence cannot be admitted without a resolved entity, a declared purpose, and an anchoring event. The first two spaces of the plane are permissive by design; the third enforces the grounding conditions.

The Mathematical Core makes the outer boundary precise. There is a boundary operation — perceive : ExternalSource → E — that is part of the algebra's language but has no CSA-internal domain. Its input is not a CSA-sort object; it is an external source. This is what it means to say the algebra begins at E: perceive sits at the threshold, and everything to the right of that threshold is governed by the algebra's types and rules. Everything to the left is the world. The asymmetry between arrival and interpretation is not a compromise; it is the design.

Event: what happened

Event Space E is the set of all occurrences the agent has perceived or derived. An event is the smallest unit the agent treats as a single happening — a click, a payment, a sensor reading, a status transition, a webhook delivery.

Three criteria must be satisfied for something to belong in E. It must have occurrence semantics — it must represent something that happened at a definite point or over a definite bounded interval. The verb-form test applies: "connected," "submitted," "triggered," "opened," "transitioned." If the candidate cannot be expressed in verb form, it probably belongs elsewhere — in D (raw data) if it is material, in K (claim) if it is a proposition. It must be source-traceable — either it arrived directly from an event source, or it was constructed by a named composition rule over events that did. An occurrence that is neither perceived nor constructed has no place in E. And it must be bounded in time — its occurrence is anchored to a specific timestamp or to a bounded interval with a defined start and end. Events without time are not events in this framework's sense.

These are membership criteria, not filtering criteria. An event that fails any of them is not rejected from E and placed somewhere else — it never enters E to begin with. A record in D that looks like it might be an event is not an event until it satisfies all three. Events have verbs. Everything else does not.

The formal structure of an event captures these requirements:

e = ⟨id(e), type(e), t(e), ρ(e), candidate_ref(e)⟩

Five projections: identifier, type (drawn from the agent's declared event-type inventory), occurrence timestamp, source provenance (which connector, which channel, when it arrived and with what payload), and candidate entity reference.

The candidate reference is worth pausing on. A candidate reference is not a resolved entity. The MQTT broker sends a payload with a device identifier in the header. That identifier is a claim from the source that this event concerns a specific subject. Whether it actually resolves to a registered entity in X is a separate question, answered at the admission gate. The event arrives in E with the candidate reference in place; it waits there until grounding catches up.

This is the gating asymmetry §5.8 of Spaces.md names. Events arrive whether or not Grounding is resolved. An event whose candidate reference cannot be resolved will sit in E without ever generating evidence — without producing signals, without reaching interpretation — but the event is preserved. Arrival and interpretation are different moments, governed by different conditions. The audit trail records what was perceived, not only what was subsequently used.

Events also come in two compositional levels: atomic and composite. Atomic events arrive directly from sources or are triggered internally by schedulers and inspection triggers. Composite events are constructed from sequences or combinations of atomics by explicit composition rules — a "purchase completed" event defined as a bounded temporal sequence of cart_started, payment_submitted, and payment_confirmed. Composite events are first-class members of E, but their constituent atomics must exist in E; composite event construction cannot fabricate the pieces it is built from.

Every ordinary observation-driven signal traces upstream to E. The signalization operator takes an event as its first argument. No event, no signal. No signal, no aggregated meaning. No aggregated meaning, no action. For every signal produced from an observation path, E is the upstream root. And the algebra's foundational statement from Chapter 2 — that raw events are binary and context gives them direction — is, in formal terms, the statement that elements of E carry no interpretive content on their own. The direction is computed downstream. The event is only the occurrence.

Raw data: what the agent has in reserve

Raw Data Space D holds everything the agent has access to, whether or not any of it will ever be used. Event payloads, CRM rows, log lines, sensor readings, documents, reference datasets, telemetry — D is permissive by design.

That permissiveness is structural. If D admitted only material already known to be relevant, the agent would have no recourse when a new purpose is activated after ingestion, when a previously-unrelated piece of material turns out to matter, or when an audit requires reconstructing what was knowable at a past moment. Raw data must be retained beyond its known utility. The discipline of what to use is enforced downstream by evidence selection; D's discipline is what to hold.

Three criteria bound D's membership: a raw data item must be accessible (the agent has a connector or channel through which it can be read), attributable to a source (every d carries provenance recording which connector, which query, when it was retrieved), and in operational scope (the agent is configured and authorized to consume material from this source). These criteria are permissive compared to I's four admission conditions — they are about availability and authorization, not about relevance or grounding.

The formal structure of a raw data item:

d = ⟨id(d), type(d), payload(d), δ(d), t_content(d), t_retrieved(d), ℓ(d)⟩

Seven projections: identifier, type, the actual content, source provenance, content timestamp, retrieval timestamp, and lineage (how this d relates to other d's and to events in E).

Two things are absent from this structure that are present in I. There is no resolved entity reference — D's items carry only whatever candidate references the source asserted, inside payload(d). There is no purpose tag — D holds material across all purposes simultaneously. The entity binding and purpose scoping happen at admission. This is why D can accumulate material before any purpose is active, and why the same d can later become evidence under one purpose and not another.

The two timestamp fields are not redundant. t_content(d) is when the source says the data was generated; t_retrieved(d) is when the agent received it. For a CRM row pulled by a scheduled connector job, these may differ by hours. For a CDC stream event, they nearly coincide. For a historical backfill, they are days apart. The distinction matters for audit and replay: to reconstruct what the agent would have known at a past time, you need to know both when the content was created and when the agent had access to it.

D is append-only at the algebraic record level — this is a property of the algebra's treatment of D, not a claim about source-system immutability. A refreshed version of an upstream record does not overwrite its predecessor; it becomes a new d with a lineage edge back to the prior version. This makes D the temporal substrate of the algebra: the material that audit and replay consult when they need to reconstruct the agent's earlier view. Remove D's historical retention and the provenance chains break; there is nothing to walk back to.

D is the agent's memory of the available; I is the agent's selection from the memorable. That is Spaces.md's formulation of D's role, and it is the one that belongs here. D does not decide what matters. It holds what is reachable. The deciding happens in I.

Evidence: admission discipline

Evidence Space I is where observation ends and interpretation begins. An evidence item is not material that happened to arrive near a relevant event; it is material that was selected under a grounding frame and admitted with argumentative force. The move from D to I is not a copy — it is a promotion. The underlying d remains in D unchanged; the evidence item in I carries lineage back to it. D retains material; I selects material.

The admission operator governs the transition:

i = ι(D_candidate, x, p, e, C_admit)

Five inputs: the candidate slice of D under consideration, the resolved entity, the active purpose, the anchoring event, and an admission context — a partial grounding frame sufficient for the admission decision. For the purposes of this chapter, the operator either admits an evidence item or rejects the candidate. ι is the only legitimate path into I.

Four conditions must hold for admission.

The evidence must be grounded — the candidate references inside d's payload must bind to the resolved entity x. Entity resolution (creating or selecting an x in X) is Entity Space's work; what ι does is verify that the material actually concerns that x. If the candidate reference in the payload doesn't match x's resolution record, or matches a different entity, no evidence item is produced.

The evidence must be event-anchored — it is selected in connection with an event that prompted attention. Reference material — policy documents, lookup tables, regulatory schedules — can become evidence, but only when an anchoring event exists: a scheduled review trigger, an evaluation-run start, an explicit request event. The anchor explains why this material is being considered now. Material without an anchor is available; it is not evidence.

The evidence must pass validation for its declared type — schema checks, freshness thresholds, source-trust minimums, completeness requirements. Validation runs as part of ι before admission. A payload that fails validation stays in D; it does not silently enter I in a degraded state.

And there is the admission context C_admit. This is not the full Context object C assembled in §2.5 and discussed in Chapter 4. C_admit is the minimal grounding frame required to decide admissibility: resolved identity, active purpose, the purpose's scope rules and constraints Ω_p, source-access policy, and the current event window. The full Context object — with complete state S(x,t), full history H(x,t), relationships network R(x,t), and trust profile Q(x,t) — cannot be assembled before evidence is admitted, because its history component requires claims to exist, and claims require evidence. C_admit breaks the loop: it is enough to decide admissibility without requiring the downstream products that admission must precede.

The result: every i ∈ I carries a resolved entity, a purpose tag, an event anchor, a quality assessment, and source lineage back to one or more d's in D.

i = ⟨id(i), type(i), x(i), p(i), e_anchor(i), d_refs(i), quality(i), t_admitted(i), ℓ(i)⟩

quality(i) is not a single number. It is a structured assessment of source trust, completeness, recency, relevance under p, and validation status, evaluated at admission time. This is admission-local quality — a snapshot of how trustworthy and relevant this item appeared when it was selected. It is distinct from the confidence q that meaning objects carry downstream; the two are related through the algebra's weighting functions, but they are not the same value.

An evidence item is fully attributed. It is not a reading; it is a reading about x, under p, because e. That attribution is the condition that makes downstream claims auditable: every claim that cites an evidence item can trace back to the entity the evidence concerns, the purpose under which it was admitted, and the event that prompted the selection.

The three failure cascades

Each space in the Observation plane has a characteristic failure mode, and each produces a different kind of downstream damage.

Event failures corrupt the arrival record. Misclassified event type means the wrong interpretation rules fire downstream — the agent processes a "demo_requested" as a "page_visited" and produces a meaning vector for the wrong context. Timestamp drift means recency calculations are wrong, decay weights are wrong, and audit replay produces results that differ from the original run with no obvious indication of why. Spurious events — test events leaked into production, misconfigured integrations, replayed events outside an authorized replay mode — make the agent produce signals from occurrences that never happened. The quiet thing about event failures is that they look like normal events; the damage surfaces much later, in the signals and meaning vectors that follow.

Raw data failures corrupt the material reserve. Stale material — D contains an old version of a record because no refresh ran — is the failure most likely to look correct while being subtly wrong, symmetric with the stale grounding attributes failure in Entity Space. Scope leakage — material entered D from a source the agent is not authorized to consume — means downstream meaning is computed against out-of-policy material while provenance appears intact. Payload corruption — malformed content, encoding errors, a partial document extraction, a checksum mismatch — means δ(d) and ℓ(d) look valid while payload(d) is unusable. The corruption is invisible until evidence selection tries to validate it.

Evidence failures corrupt the claims. False admission — material was promoted to I that shouldn't have been, because entity binding was not enforced, because an anchor was accepted without verification, because validation was bypassed — is the failure closest to "garbage in, garbage out," but harder to detect because the output looks like valid, attributed evidence. False rejection is the symmetric problem: filtering tuned too strictly means the agent forms claims from an incomplete base. Stale evidence — an item that remains in I after the underlying d was superseded by a newer version in D — means claims reference material the agent has already received a fresher version of.

The shared pattern across all three: the failure does not announce itself at the space where it occurred. A misclassified event does not produce an error at perception; the error surfaces in Interpretation, where the wrong rules fired. Stale material does not produce an error sitting in D; it surfaces in the signal that used it. False admission does not produce an error at the gate; it produces a claim that is structurally well-formed but referentially wrong. In the Observation plane, as in Grounding, errors propagate forward.

The three together

E, D, and I answer the observation question jointly. E introduces occurrence — what just happened? D holds material in reserve — what do we have available? I selects with argumentative force — what have we admitted as worth reasoning about?

The Observation plane's mandate is to prevent the boundary between arrival and admissibility from collapsing. If every event that arrived were automatically evidence, the agent would reason about everything it received — including events that concern unresolved subjects, events from misconfigured sources, events that arrived before a purpose was active, and events whose candidate references cannot be verified. The output would look like meaning. It would be noise with provenance attached.

The admission gate is not a filter in the pejorative sense. D retains everything. The gate is a discipline: it enforces that reasoning happens about identified subjects, under declared purposes, because specific occurrences warranted attention, on validated material. Remove it and the algebra's downstream structure — the meaning vectors, the signals, the aggregated conclusions — is computing over unattributed readings. The numbers are correct. The referents are absent.

Chapter 6 begins at the moment I is populated. Entity is resolved, purpose is active, events are in E, and evidence has been admitted into I under a grounding frame. The Interpretation plane's question is: given this evidence, under this purpose, about this entity, what claims can be formed and what features can be extracted?

The evidence gate has closed.

Chapter 5 ended at the moment evidence is admitted into I: the entity is resolved, the purpose is active, material is in reserve, and specific items have been selected as worth reasoning about under the grounding frame. Everything to the left of I is observation. Everything to the right of it is interpretation.

The Interpretation plane contains two spaces. Claim Space K converts evidence into asserted propositions. Feature Space F converts the assembled context and evidence into typed measurements. Neither is more fundamental than the other; they answer different questions about the same grounded situation. A claim says what the agent holds to be true about an entity. A feature says what is quantifiably the case about an entity's situation. Both feed downstream meaning — but through different mechanisms, at different points in the flow, and with different relationships to the grounding frame.

The Interpretation plane

The Interpretation plane is split. That split is structural, not an implementation detail.

K precedes full Context assembly; F follows it. Claims are formed against C_admit — the partial grounding frame that was sufficient to gate evidence admission in Chapter 5. Features are computed against full C — the assembled situational frame that includes the state component that K has just populated. The Grounding plane's re-entry, described in Chapter 4, happens between K and F: the agent leaves Grounding after establishing X and P, runs through Observation and through K, then returns to Grounding to assemble C from the claims K has produced.

Compressing the already-covered E/D arrival path, the relevant order here is:

X, P → C_admit → I → K → C → F → Z → α → A

This order is not arbitrary. Claims must precede full C because the state component of C is the set of active claims. Full C must precede features because features are computed within the assembled situational frame. Every attempt to compute a feature at admission time — before claims exist, before C is fully assembled — is a stage confusion. The algebra detects and rejects it.

The split answers an important question the Chapter 4 reader might have left open: if K uses C_admit, and C_admit excludes current-run claims, how can C's state component ever be non-empty? Because K runs before C is assembled. The cycle — "I need state to form claims, but state requires claims" — is broken by the C_admit / full-C distinction. Claims are formed against prior-run state; then full C is assembled from those claims; then features are computed against full C. No step reads the output it is supposed to be producing.

Claims: turning evidence into positions

Claim Space K is the set of all typed propositions formed by the agent about entities within its operational scope.

The central distinction is not between claims and evidence — it is between material with argumentative force and that force being spent. Evidence says: this material exists, it concerns this entity, it passed validation under this purpose, and it was admitted because this event prompted attention. A claim says: given that material, I am asserting this proposition, about this entity, with this degree of commitment.

The difference is a commitment. Evidence is preserved in D and selected into I; it is not affected by what happens upstream. A claim is a new object — one that takes evidence as inputs and produces an assertion as output.

Four criteria bound K's membership. A claim must be propositional: it takes the form of a typed predicate over arguments, where the predicate is drawn from the agent's declared predicate inventory under the active purpose. A candidate that cannot be expressed as a typed proposition is not a claim. A claim must be entity-grounded: its primary argument is a resolved x ∈ X. A claim must be evidence-supported: it references one or more admitted evidence items as the material it draws on. A claim without supporting evidence is rejected at formation, not silently admitted. And a claim must be purpose-scoped: it is formed under a specific p ∈ P. Purpose-scoping is a typing and provenance condition, not evidential justification. It records the purpose under which the claim was formed; the evidence, stance map, and predicate rules determine whether the claim is supported.

The claim operator κ governs formation:

k = κ(I_relevant, predicate, x, p, C_admit)

Five inputs: the evidence items under consideration, the typed predicate being asserted, the entity, the active purpose, and the admission context. κ either forms a claim or rejects the candidate. κ is the only legitimate path into K.

What κ produces has ten projections:

k = ⟨id, predicate, x, args, p, stance_map, q, t_formed, ℓ, rule_ref⟩

The identifier and predicate are straightforward. The entity and purpose carry provenance. The additional arguments cover predicates that take more than an entity — a stage name, a cause class, a policy version. Formed time records when the claim was produced.

Two projections are worth dwelling on.

The stance map is what makes a claim auditable rather than merely attributable. It assigns, for each referenced evidence item, one of four typed relationships: supporting, contradicting, qualifying, or neutral. Supporting evidence raises the claim's confidence; contradicting evidence lowers it; qualifying evidence conditions it — it supports the claim in a constrained way, limits its scope, or introduces a caveat. Neutral evidence is preserved for audit without contributing directional force. An auditor reading a claim can ask: which evidence supports this? Which contradicts it? Which qualifies it? The stance map gives typed answers.

The confidence q(k) is computed from the full stance map and the quality assessments of each referenced evidence item. It is not asserted manually, not inferred opaquely, and not set by fiat. The confidence function is versioned alongside the predicate inventory, so replay can reproduce historical confidence values when rules have changed.

Claim lineage ℓ(k) records the chain of revisions, retractions, and supersessions that connect this claim to its predecessors. Claims are append-only: a claim, once formed, is not modified. Revision produces a new claim with updated confidence and a predecessor link; retraction produces an explicit retraction claim linked to the claim it withdraws; supersession produces a new, more specific claim that makes an earlier general one obsolete. The full history of what the agent has believed about an entity-predicate-purpose triple is reconstructible from ℓ.

The commitment the stance map makes visible

It is possible to have material without a position. D retains everything the agent has access to. I holds what was admitted. Neither commits the agent to any assertion about the entity.

K is where the agent commits. The commitment has two faces.

The first face is the predicate: the agent says "this entity is qualified," or "this incident's root cause is a network timeout," or "this purchase order is policy-conformant." These are typed positions — not hedges, not possibilities, not available readings. The confidence q(k) expresses the agent's degree of commitment, not whether it is committed at all. A claim with q = 0.45 is still a claim; it is simply a claim held with lower confidence.

The second face is the stance map: the agent does not merely assert a position, it records how each piece of evidence contributed to that position. This is what separates K from a label store. A label store might say "qualified: true." K says "qualified: true, with confidence 0.86, where evidence item i₁ (a CRM status row) is supporting, evidence item i₂ (recent activity logs) is supporting, and evidence item i₃ (a single data point two weeks old) is qualifying." An auditor reading the claim knows not just what the agent asserted but what the assertion is made of.

In a rule-governed evaluation domain, an eligibility claim — "this applicant meets the structural eligibility criteria" — carries a stance map over the evidence items checked: the submitted documents, the extracted fields, the validated constraint checks. The confidence reflects whether the evidence base is strong or hedged. The purpose-scope tags the claim to the eligibility-review run that produced it. The entity reference resolves to the specific application, not to a class of applications. The predicate is drawn from the domain's declared predicate inventory for that review purpose. The claim is a position on a specific subject, not a summary judgment about a category.

The PrintFarm domain makes the same point from the physical end of the spectrum. The claim-forming agent in that domain produces propositions about specific print jobs — job states, failure modes, plate bindings, material conditions. The algebra's claim structure generalizes across both domains because K's criteria are domain-neutral: propositional, entity-grounded, evidence-supported, purpose-scoped. The predicate inventory changes; the structure does not.

K's downstream role is precise: it populates the state component of Context. S(x, t, p) is, formally, the set of claims about x active at time t under purpose p:

S(x, t, p) = K_active(x, t, p) = { k ∈ K : x(k) = x, p(k) = p, status_t(k) = active }

This is the forward edge that completes the Grounding re-entry. Context begins with identity (from X) and purpose (from P); its state component is empty until K produces claims; once K has run, full C can be assembled. Without K, C has no state. Without state, C is a shell — identity and purpose without any assertion of what is currently true about the entity.

Features: turning context into measurements

Feature Space F is the set of all computable, typed projections from context and evidence that the agent produces during its interpretation of an entity under a purpose.

The distinction between F and K is not about precision or depth. It is about the kind of thing produced. K produces propositions: the agent holds something to be true. F produces quantifications: the agent measures a specific computable aspect of the entity's situation.

The claim qualified(x) is in K. The feature qualification_score(x) = 0.86 is in F. They concern the same entity. They may reference some of the same evidence. They are different objects: the first is a commitment; the second is a measurement.

Four criteria bound F's membership. A feature must be computable — produced by a defined, versioned computation rule, not inferred informally or extracted without an explicit procedure. A feature must be typed — it has a declared output type (scalar, categorical, integer count, normalized score, duration, structured value) and a declared semantic interpretation that says what the value means operationally. A feature must be purpose-scoped — computed under a specific p. The same underlying computation may produce two distinct features under two different purposes if the semantic interpretation differs: days since last contact reads as a recency signal in one domain and a neglect-risk indicator in another. A feature must be traceable — every f carries lineage references to the components of C and the evidence items from which its value was computed.

The feature operator χ governs computation:

f = χ(feature_id, x, p, C(x, t, p), I_relevant)

Five inputs: the feature to compute (drawn from the agent's feature inventory T_F), the entity, the active purpose, the full assembled Context, and the evidence slice the rule is permitted to read. The distinction from κ is not just the output — it is the input. χ requires full C, not C_admit. Features cannot be computed at admission time because they integrate over claims, history, and assembled context that do not yet exist at admission.

A feature value has nine projections:

f = ⟨id, feature_id, x, p, C_ref, value, inputs_refs, t_computed, rule_ref⟩

Most are parallel to K's structure: identifier, type drawn from inventory, entity, purpose, the rule reference that makes replay possible, and the lineage from which the value was computed. Two are specific to F.

C_ref records not the context object itself — C is assembled on demand, not stored persistently — but a tuple sufficient to reconstruct it during audit and replay: entity, context time, purpose, and assembly-recipe version. This is how a feature anchors to its grounding without holding full C by value.

value is the typed output: a scalar, integer, categorical label, normalized score, duration, or structured value. The type is declared by the feature inventory entry for feature_id; a value that does not match the declared type is rejected. Feature computation does not silently coerce.

Features are append-only. Recomputation under updated rules or updated inputs produces a new f with its own id and t_computed; the previous value remains in F for audit. An auditor reconstructing what the agent was operating on at a past moment reads the features computed before that moment, not later recomputed values.

A note on operator signatures. The interpretation and signalization operators — η and σ — depend on features as well as on C and I. When written in shorthand as η(e, x, p, C, I) and σ(e, x, p, C, I), the F_relevant slice is implicit. The full signatures are:

μ = η(e, x, p, C, I, F_relevant) z = σ(e, x, p, C, I, F_relevant)

Features are the measurable substrate the Meaning plane reads from. The directional reading — whether a particular measurement value is high or low, urgent or stable, healthy or at risk — happens in M through η and σ, not in F. F does not say whether three email opens in 48 hours is good; it says the value is 3.

The three-level distinction

E, D, and I answer the observation question. K and F answer the interpretation question. Three levels of the algebra's structure are now in view together.

Evidence is material with argumentative force. It is admitted, not formed. It concerns an entity, is anchored to an event, passes validation, and can be traced to a raw data item and through it to a source. Evidence does not assert anything; it provides the substrate for assertion.

A claim is a proposition that spends evidence's argumentative force. It is formed, not admitted. It commits the agent to a typed predicate about a specific entity, records how each evidence item contributed to the commitment, and carries a confidence computed from that record. A claim asserts; it does not merely present.

A feature is a typed measurement computed from the assembled context and evidence. It is computed, not formed or admitted. It quantifies a specific computable aspect of the entity's situation under the active purpose. A feature does not assert; it measures.

The three are not interchangeable, and collapsing them is one of the more consequential ways agent pipelines go wrong. An agent that treats evidence as sufficient for action has skipped commitment — it responds to material that arrived, not to positions about specific subjects. An agent that treats claims as measurements has lost the stance map — the record of how evidence contributed to each assertion. An agent that treats features as claims has confused quantification with proposition — it asserts that a measurement value constitutes a position, when positions require evidence and stance, not just a computation and a threshold.

Together, they implement the algebra's interpretive chain: observation selects material; claims spend that material on specific propositions; features measure the quantifiable aspects of the grounded situation.

The failure cascade in interpretation

Each space in the Interpretation plane has a characteristic failure mode, and each produces a different kind of downstream damage.

Claim failures corrupt the agent's positions. An unsupported claim — formed without sufficient evidence, without enforcing minimum-support rules — is a position with no ground under it. The agent commits to a proposition its evidence does not actually support; downstream meaning is computed against that proposition as if it were well-founded. A stale claim — an active claim that should have been revised or retracted when contradicting evidence arrived — is a position that no longer reflects what the agent's current evidence base would support. A contradiction unhandled — two active claims about the same entity-predicate-purpose triple asserting opposite things, neither retracted — means Context's state component is incoherent; downstream operations consult whichever claim is selected, with no principled rule for the choice.

Feature failures corrupt the agent's measurements. A stale feature — a value computed against a prior version of C or I — means meaning is computed against a measurement that has been superseded by updated context. An untraceable feature — a value whose inputs_refs do not reference identifiable components of C or I — means provenance traversal breaks; an auditor cannot reconstruct why the feature has the value it does. Cross-purpose contamination — a feature computed under one purpose consumed by an operator running under another without explicit authorization — means meaning is computed under one frame using quantification derived under another.

The shared pattern: interpretation failures surface downstream, not at the space where they occur. A stale claim does not produce an error sitting in K; it produces a distorted meaning vector in M. An untraceable feature does not produce an error at χ; it breaks the audit trail an operator needs to walk back from an action. Errors propagate forward, as in the Observation plane.

What the Interpretation plane produces

K and F together prepare what the Meaning plane will read.

From K: asserted propositions with grounded confidence and typed evidential support. These are not raw readings; they are positions the agent has committed to, about specific entities, under declared purposes, with every piece of supporting, contradicting, qualifying, and neutral evidence accounted for.

From F: typed measurements computed from the assembled context and evidence. These are not directional readings; they are the measurable substrate from which direction will be computed — scalars, counts, scores, and durations that downstream operators can compose into vectors.

The Meaning plane's question — given this grounded situation, what does it mean under this purpose? — is only answerable because K has produced claims and F has produced features. Without claims, C has no state and meaning has no propositions to weigh. Without features, the meaning operators have no typed inputs to compose into directional vectors.

Chapter 7 begins at the moment K and F are populated and C is fully assembled. The Meaning plane's work is to take that committed, measured, grounded situation and compute what it signals — to produce directional outputs that, when aggregated, produce the action-ready meaning objects from which agents act.

Where we are

Chapter 5 produced a cleared evidence base: events in E, raw data in D, admitted evidence in I. Chapter 6 produced claims in K and measurements in F, all sitting in an assembled context C. The Observation plane's question was what material arrived and what survived admission. The Interpretation plane's question was what the agent asserts and what it measures. The answer to both is now in C.

The Meaning plane asks a different question: given this grounded, populated context — what does the situation actually point to, and in what direction, with what strength?

The Meaning plane has three spaces that answer this question in sequence. M provides the typed vector substrate in which a directional reading lives. Z packages that reading into a provenance-bearing signal object a downstream consumer can use. m accumulates those signal objects into an entity-level picture sufficient to drive action. Each space has its own operator and its own discipline. Together they execute what the algebra describes as the move from interpretation to meaning: not a label assigned after the fact, but a directional vector produced under a purpose, carried forward with its provenance, and accumulated only when compatible readings can justifiably compose.

Meaning as a vector, not a label

The commitment encoded in M's definition is structural, not stylistic.

M is the Meaning Space defined as a disjoint union of purpose-conditioned vector spaces:

M = ⨆_{p ∈ P} M_p

Each M_p is a separate vector space whose basis, dimensionality, normalization convention, and version reference are declared as part of the purpose p's specification. M_sales and M_security may share axis names — "urgency" appears in both — but they are different spaces. Urgency in a sales context tracks time-sensitivity of a buying decision; urgency in a security context tracks how quickly a threat must be contained. The two have different range conventions, different sign interpretations, and different composition rules. An operator that sums a vector from M_sales and a vector from M_security without an explicit cross-purpose projection has performed a type error the algebra cannot recover from.

A label would compress this structure. "High urgency" in a sales context and "high urgency" in a security context collapse to the same string. Nothing downstream can detect the type mismatch. A vector retains it: M_sales vectors do not compose with M_security vectors, the composition attempt fails with a type check, and the source of the failure is traceable.

The four downstream payoffs of vector-valued meaning are comparability (two M_p vectors can be inner-producted; their similarity is a real number in a declared range), composability (multiple M_p vectors can be summed or composed according to the purpose's declared aggregation rule, yielding another M_p vector), projectability (any component of a meaning vector can be extracted as a scalar, and that extraction is semantically meaningful because the axis has a declared definition), and conflict-resolution-with-provenance (when two M_p vectors are anti-aligned, the conflict is detectable, and its provenance — which events, which evidence, which claims — is traceable through the signal objects that carried those vectors).

Each M_p has a four-field schema. basis(M_p) is the ordered list of named, typed, sign-convention-bearing, range-bounded, semantically-defined axes; the names are not cosmetic — they carry the semantic commitment about what each axis measures. dim(M_p) is the cardinality of the basis. normalization(M_p) is the per-axis range convention (unit sphere, bounded interval, log-scale, etc.). version_ref(M_p) ties the schema to the version of the purpose specification ν(p) that declared it. The version reference is load-bearing: if M_p's basis changes without advancing version_ref, old μ vectors and new μ vectors are silently treated as elements of the same space while pointing along different semantic axes. That is the basis-drift failure mode, and it surfaces downstream, not at the point of mutation.

The schema must be registered before any meaning vector can be computed under p. There is no fallback space. Without a registered M_p, the η operator has nowhere to produce output.

η: the interpretation operator

The Meaning Space M is populated through one operator: η.

μ = η(e, x, p, C, I, F_relevant)

Six inputs: the triggering event e, the resolved entity x, the active purpose p, the full assembled context C, the admitted evidence base I, and the relevant feature slice F_relevant (the features computed under p for entity x at the current time). η is the only operator that produces a fresh meaning vector from raw inputs. It is the algebra's formal account of what it means to interpret: not to assert (that is κ in K), not to measure (that is χ in F), but to produce a directional reading of what a situation means for a specific entity under a specific purpose, given everything the agent knows.

The lighter form μ = v(e) · w_p · φ(C) — event contribution times purpose weighting times contextual transformation — is what η's body computes in the simplest case. It is a contribution-decomposition: v(e) captures how much the event itself moves the reading; w_p captures the scaling the purpose applies to that raw contribution; φ(C) captures how the assembled context transforms the meaning of the event for this entity at this time. The full six-input signature is what η actually takes; the decomposed form describes the algebra inside η's body.

A μ produced by η has two properties: direction (which way it points in M_p, captured by its basis-component values) and strength (how far from the origin it sits, captured by its norm ||μ||). A zero-strength reading is not an absent reading — it is a reading that the situation points to the origin of M_p, which has a distinct semantic interpretation under the purpose's normalization convention. The algebra distinguishes zero-strength from no-reading.

What μ does not carry is the entity it was computed for, the event that triggered it, the timestamp, the confidence, or the provenance trail. Those are not M's concern. M is a typed vector substrate. The signal object z is what wraps μ with everything needed for downstream use.

σ and Z: meaning packaged for downstream use

A meaning vector μ produced by η exists in M_p. It has no entity. It has no provenance trail. It cannot be aggregated without knowing which entity the reading is about, when it was produced, what evidence it was derived from, how confident the computation is, and what purpose it is typed against. Signal Space Z provides all of this.

The signal-producing operator is σ:

z = σ(e, x, p, C, I, F_relevant)

The same six inputs as η — because σ invokes η internally and then wraps the result. A specific signal z in canonical form is:

z = ⟨x, e, μ, q, π, p, C⟩

Seven fields: the entity, the triggering event, the meaning vector, a confidence, a provenance trail, the purpose, and a context reference. The full eleven-field form adds id, t_emitted, rule_ref, and ℓ (the level designation). Together, the seven canonical fields make μ usable by everything downstream: aggregation, action dispatch, audit, replay, and monitoring.

σ's body executes in four stages. First, event and entity resolution: the triggering event e and the resolved entity x must both be present and have passed their resolution gates. σ does not resolve entities — it requires them already resolved. Second, context consultation: σ reads the full C(x, t, p), which carries the entity's current state, K_active (the claims currently held about x under p), the evidence history, the temporal frame, trust weights, relationship graph, constraints, and the active purpose. The context is the frame that gives meaning to the event. Third, interpretation: σ invokes η to compute μ = η(e, x, p, C, I, F_relevant). The meaning vector is computed fresh from the current inputs — not retrieved from cache. Fourth, signalization: σ evaluates confidence q, assembles the provenance trail π, assigns the signal id and t_emitted, sets ℓ = 2 (contextual signal level), and packages the eleven-field result.

Two fields of z deserve sustained attention.

Confidence q(z) is computed from the quality of the contributing evidence items (their verification statuses, trust weights, source provenance), the confidence of claims consulted through K_active, and purpose-specific calibration factors encoded in Ω_p. Confidence is not the same as strength. Strength ||μ(z)|| answers "how much directional reading did the agent produce for this entity under this event?" Confidence q(z) answers "how trustworthy is that reading given the quality of the inputs that produced it?" The two are orthogonal. A high-strength reading derived from a single low-quality, unverified evidence item carries high strength and low confidence. A moderate-strength reading derived from three independent, verified, coherent evidence items under a purpose that has been calibrated over many cycles carries moderate strength and high confidence. Downstream action dispatch depends on both, independently. An agent that multiplies strength by confidence before dispatch has collapsed two distinct quantities into one and lost the information that distinguishes "act cautiously on a strong signal we don't trust" from "act normally on a moderate signal we trust fully."

Provenance trail π(z) is the structure that makes the entire audit and replay chain of the algebra possible. π(z) traces backward from μ through the features in F_relevant that contributed to the computation, through the evidence items in I those features and the context consulted, through the events in E those evidence items were anchored to, and through the raw data items in D those events emerged from. An agent can traverse π(z) and reconstruct, for any signal z, exactly which raw material was observed, how it was admitted into evidence, what claims and features were formed from it, and how those fed into the meaning vector. A signal without a traversable π is not a signal the algebra recognizes; it is a free-floating vector whose origin cannot be recovered.

Signals are append-only at the algebraic record level. A signal once emitted is not modified. If new information requires a revised reading, σ produces a new z with a predecessor link to the original. If a signal is retracted, the retraction is an explicit marker in Z, not an in-place deletion. This is the same discipline the algebra applies to evidence in I and to raw data records in D: the algebra's record of what an agent concluded must be as stable as the algebra's record of what it observed.

The temporal decay function captures how a signal's relevance changes over time:

recency(z, t) = exp(-λ · (t − t_emitted(z)))

The decay rate λ is purpose-specific. A signal about a printer's temperature has a fast decay — the reading from six hours ago is nearly irrelevant to current dispatch. A signal about an applicant's eligibility history has a slow decay — old signals carry weight through the evaluation. The recency function feeds into aggregation weighting; it does not modify the signal itself.

Three levels

The algebra's three-level progression is made precise through Z's level designation ℓ.

Level 1 is the raw event e ∈ E. A Level 1 object answers one question: did something happen? An event carries the occurrence itself, a source provenance, and a timestamp. It carries no direction. It records only occurrence: this event occurred at this time, from this source. Everything that turns an event into something an agent can act on is upstream of Level 1's definition.

Level 2 is the contextual signal z ∈ Z, ℓ = 2. A Level 2 object answers: what does this event point to, for this entity, under this purpose, in what direction, with what strength, with what confidence, and with what provenance? The contextual signal is not a richer event. It is a different kind of object, in a different space, produced by a different operator, from different inputs. What progresses from Level 1 to Level 2 is not the event — the event stays in E — but the interpretive commitment: from "something happened" to "something happened and here is what it means for x under p."

Level 3 is the aggregated meaning α ∈ m, ℓ = 3. A Level 3 object answers: given all the readings this agent has produced for this entity under this purpose over this temporal window, what is the accumulated picture, and is that picture sufficient to drive action? Aggregated meaning is not a richer signal. It is an entity-level object that answers a question no single event-local signal can answer.

Z is event-local. m is entity-level accumulation. The Action plane consumes α, not z. An agent that dispatches on individual signals — that issues a directive based on a single event's directional reading, without accumulation — has treated a snapshot as a picture. The algebra makes this structurally explicit: ψ's input type is the action-ready meaning object from m, not a signal from Z.

Agg and m: accumulation before action

Aggregated Meaning Space m is the set of all entity-level, time-indexed, purpose-typed aggregated meaning objects the agent has produced. A specific aggregated meaning α ∈ m_p is a five-criterion object: it is entity-anchored (scoped to a specific x), purpose-typed (M_p, not any other M_{p'}), time-indexed (anchored to an aggregation time t), signal-derived (substantively populated from the contributing signals, not from direct context access), and provenance-bearing (carrying the union of the contributing signals' provenance trails).

The aggregation operator is Agg:

α(x, t, p) = Agg({zᵢ}, C(x, t, p), p)

Three inputs: the eligible signal set (a subset of Z scoped by entity match, purpose match, and temporal window eligibility); the full context for aggregation parameter lookup; and the active purpose as the rule selector that determines which aggregation rules apply. Agg's substantive content comes from the signals: the μ's and π's of the contributing zᵢ. C supplies parameters — temporal window bounds, eligibility thresholds, trust floors, aggregation rule references. The state components of C (K_active, features, prior actions) reach Agg only indirectly, through having already influenced which signals were produced and what μ's they carried.

Agg executes in four stages. Signal selection: from Z, retain signals that pass entity-match (z.x = x), purpose-match (z.p = p or a declared compatible purpose), temporal-eligibility (t_emitted within the window), and quality-floor (q(z) ≥ threshold(Ω_p)) filters. Weighting: each surviving signal zᵢ receives a weight combining importance(Ω_p, zᵢ), trust(zᵢ), relevance(zᵢ, x, t), and recency(zᵢ, t). Composition: the weighted signals are composed according to the purpose's declared aggregation rule — sum, decayed sum, percentile composition, or conflict-resolved composition. Conflict and confidence resolution: if contributing signals are directionally anti-aligned, Agg does not silently average through them; it flags conflict_markers(α) and adjusts q(α) to reflect the contested state.

The output is wrapped into the action-ready meaning object:

⟨x, p, α, q, π⟩

This five-tuple is what ψ consumes. x is the target entity. p is the active purpose. α is the aggregated meaning value (the purpose-typed vector in M_p). q is q(α), the aggregation-level confidence. π is π(α), the union of the contributing signals' provenance trails extended by the aggregation operation. The five fields are named explicitly even though all are derivable from α's internal structure — the same convention z uses, for the same reason: every downstream consumer needs the fields without unwrapping the aggregation object on every access.

Two structural commitments of Agg are load-bearing for the action plane.

q(α) and value(α) are orthogonal in dispatch. The strength of an aggregation is ||value(α)|| — how much directional reading the composition produced. The confidence is q(α) — how trustworthy that composition is given the quality and coherence of the contributing signals. An agent that scales value(α) by q(α) before presenting the result to ψ has collapsed two independent quantities into one. The action plane's dispatch rules in Ω_p specify separate thresholds for value direction (which action to select), value strength (whether the action is the full response or a scoped version), and confidence (whether to proceed, restrict to reversible options, or defer to human review). Conflating value and confidence before dispatch is a way to confuse "we have a strong signal we do not trust" with "we have a moderate signal we trust fully" — a confusion with different dispatch implications.

Cancellation is not quiet. When contributing signals are strongly anti-aligned — when M_p vectors in opposite directions have been produced for the same entity under the same purpose within the aggregation window — their composition may yield a small ||value(α)||. A naive reading is that the entity's situation is quiet, unremarkable. The correct reading is that the situation is contested: strong evidence points one way, strong evidence points the other, and the agent has not resolved the conflict. Agg is required to detect anti-aligned signal clusters, populate conflict_markers(α) when they occur, and ensure that ψ and any monitoring layer receive the conflict signal explicitly. Silent sum-through of anti-aligned signals is not a weak aggregation choice; it is an invalid aggregation outcome. Agg must mark the conflict or withhold an action-ready object. Meaning must accumulate before it can drive action — and the accumulation must report what it found, not just what it computed.

Purpose isolation and the meaning cone

The Meaning plane enforces purpose isolation structurally.

The disjoint union M = ⨆{p ∈ P} M_p is not a stylistic choice; it is the formal statement that no inner product, no norm, no projection is defined across different M_p subspaces by default. Every η call, every σ wrapping, every Agg composition carries a purpose type tag, and every operator that consumes M-typed objects checks that the tags match. An agent that combines μ from M{p₁} with μ from M_{p₂} without an explicitly declared cross-purpose projection has produced a type error, not a meaning.

The cross-purpose projection operator Π_{p₁→p₂} is the only declared path for moving a meaning vector from M_{p₁} to M_{p₂}. It must be declared per ordered pair (p₁, p₂), versioned alongside ν(p₁) and ν(p₂), and accompanied by a documented axis mapping that explains what each M_{p₁} axis corresponds to in M_{p₂}'s basis. The use of any Π is recorded in the provenance trail of the resulting signal — a crossing that cannot be hidden and cannot be post-hoc justified. Most purpose pairs in a deployed agent have no Π defined. This is the correct behavior. The overwhelming majority of cross-purpose flows in systems without explicit structure are silent contamination, not declared transport. Π's existence in the algebra defines the mechanism; the absence of a Π declaration for a given pair means the operation is not available for that pair.

The Mathematical Core's ruling on what Π governs — the border between what is permitted and what is forbidden in cross-purpose meaning flows — is precise.

The algebra distinguishes two kinds of cross-purpose relationship. The first is observational coupling: a purpose p₂ may observe the consequences of a purpose p₁'s actions, because those consequences are events in E — the feedback boundary — that p₂ may encounter through the ordinary evidence admission cycle. An action emitted by p₁ changes the world; the change registers as events; p₂ may observe those events; p₂ computes its own meaning from its own evidence. No Π is involved. No meaning vector crosses. The observation is through E, where information arrives as raw events and passes through the full admission and interpretation chain before becoming meaning.

The second kind is meaning borrowing: consuming a μ produced under p₁ as if it were p₂-typed meaning, without a declared Π. This is what the algebra forbids. The borrowed μ is typed against M_{p₁}'s basis, with M_{p₁}'s normalization, under M_{p₁}'s sign conventions. Using it as M_{p₂}-typed input is a type error. Even if the axis names overlap, the semantic commitments differ. And there is no provenance trail for the crossing — the μ arrives in M_{p₂}'s computation with no record of where it came from or what transformation, if any, was applied.

CSA allows observational coupling; it forbids unauthorized meaning borrowing. A purpose may observe the consequences of another purpose's actions; it may not borrow its interpretation. Observation is through E — the feedback boundary — where each purpose applies its own η to the events it encounters. Borrowing is through Π — an explicit, declared, versioned, provenance-recording transport. The two are structurally different operations. Conflating them — treating "we saw what the other purpose produced" as equivalent to "we may use what the other purpose computed" — is the failure mode M5 is designed to name.

The meaning cone π_M is the restriction of the full provenance cone π to the M-fibered edges: those edges in the provenance graph that carry a M_p-typed value. The meaning cone makes it possible to audit not just that a signal was produced correctly, but that no M-fibered value entered the computation through an undeclared path. The context channel closed lemma establishes that no component of C is M-fibered — K_active carries claims (K-typed), features carry typed quantifications (F-typed), the action history carries action records (A-typed). C's content does not include meaning vectors. The only way meaning enters a new η computation is through the event and context inputs that describe the current situation, not through C importing a prior meaning.

The failure cascade in meaning

Each space in the Meaning plane has characteristic failure modes, and each failure surfaces downstream rather than at the point of origin.

Meaning failures corrupt the vector substrate before a signal is produced. The most dangerous is basis drift without version provenance: M_p's axes are updated — a new axis added, an old axis redefined — without advancing version_ref(M_p). Old μ vectors and new μ vectors both pass the M_p membership check; their components no longer align along the same semantic axes; aggregation silently mixes structurally incompatible vectors and produces a numerically valid but semantically meaningless result. The failure is invisible at the M level and surfaces when an operator reviews why α pointed strongly in a direction no contributing evidence supported. Silent cross-purpose mixing — a μ from M_{p₁} summed with a μ from M_{p₂} without invoking Π — produces the same downstream pathology with no audit trail to follow.

Signal failures corrupt the provenance chain or the type wrapping. A provenance break in π(z) — a reference to an evidence item whose payload has been corrupted or whose record has been lost — means the audit trace cannot reconstruct why μ has the values it does. Cross-typed wrapping — a signal emitted under purpose p carrying a μ typed against M_{p'} — means aggregation under p reads vectors from the wrong basis without a type error, producing an aggregated meaning whose components are dimensionally incoherent. Stale signal retention — a z that should have decayed past its relevance window remaining in the aggregation-eligible pool — means the entity-level picture is computed against an outdated event-local reading.

Aggregation failures corrupt the entity-level picture the action plane acts on. A stale aggregation — α remaining in the active subspace after the temporal window it was computed for has passed — is the aggregation-level version of every stale-object failure in the algebra: ψ acts against an outdated picture because no invalidation signal has updated α. Silent conflict is the failure the algebra guards against most explicitly in Agg's specification: contributing signals are anti-aligned, Agg sums through them, conflict_markers(α) is empty, q(α) is high because the signals individually had high confidence, and ψ sees what appears to be a high-confidence, low-strength, quiet situation when the correct reading is a high-confidence, contested situation. The agent acts routinely on a case the evidence said was contested. Conflict markers are not optional metadata; they are the mechanism by which the accumulation stage reports what it actually found.

What the Meaning plane produces

The Meaning plane's output is the action-ready meaning object: ⟨x, p, α, q, π⟩.

It is not an action. ψ — the action operator that belongs to Chapter 8 — receives this object and must still decide what to do with it. The decision depends on what direction value(α) points in M_p, how strongly (||value(α)||), how confidently (q(α)), whether conflict_markers(α) is populated, and what the purpose's declared action repertoire and dispatch thresholds in Ω_p specify.

The Meaning plane's contribution is that by the time ψ receives this object, the reading has been grounded (the evidence it rests on passed admission), interpreted (claims and features were formed and verified), assembled (the context carried the full operational picture), computed into a typed vector (η produced μ), carried with provenance (σ wrapped μ into z), and accumulated across compatible signals (Agg composed the eligible signals for this entity under this purpose at this time). None of that work is repeated at ψ. ψ selects and emits. The preparation is complete.

Chapter 8 begins at the moment the action-ready meaning object exists.

M = ⨆_{p ∈ P} M_p

μ = η(e, x, p, C, I, F_relevant)

z = σ(e, x, p, C, I, F_relevant)

z = ⟨x, e, μ, q, π, p, C⟩

recency(z, t) = exp(-λ · (t − t_emitted(z)))

α(x, t, p) = Agg({zᵢ}, C(x, t, p), p)

⟨x, p, α, q, π⟩

Where we are

Four upstream planes of the algebra have run their course. X and P resolved the entities and purposes the agent operates over. C_admit assembled the context the admission operators needed. E, D, and I ran the observation cycle: events arrived, raw material accrued, evidence was admitted under purpose and entity. K and F ran the interpretation cycle: claims were formed from evidence, features computed from the full context. M, Z, and m ran the meaning cycle: typed directional readings were computed from evidence and context, wrapped into provenance-bearing signals, and accumulated into entity-level aggregations.

At the end of Chapter 7, the algebra had produced an action-ready meaning object: ⟨x, p, α, q, π⟩. The entity is resolved. The purpose is active. The aggregated meaning carries direction, strength, and confidence. The provenance trail reaches back through every step that produced it.

Action is not execution. Execution is what happens in the world after the agent commits; action is the committed emission the algebra records.

The Action plane answers the final algebraic question: what does a system that has done all of this actually do?

The answer is specific. The agent emits a committed decision — an action a ∈ A — that is entity-targeted, purpose-scoped, aggregation-grounded, repertoire-conformant, and approved according to the constraints the purpose declares. It records that commitment with full provenance and approval-state. It releases the action's effects into the world, where they arrive back as new events in E and start the cycle again.

The Action plane has one space and one operator. A is the set of all actions the agent has actually emitted. ψ is the operation that produces them. The brevity is not simplicity — it is precision. The pipeline's complexity is upstream. At ψ, the algebra has one job: emit or produce a structured control outcome.

A: committed action, not considered action

The first and most consequential thing to understand about A is what it does not contain.

A does not contain action proposals. When an agent is configured to recommend rather than act — because the action type requires human authorization, or because a policy gate has not been cleared, or because the agent has been deployed in advisory mode — the proposal it generates is a control-layer record, not an element of A.

A does not contain queued approvals. A candidate action that ψ has routed to a human for sign-off has not been emitted. It is pending. It will either produce an element of A when the approval clears and ψ fires in emission mode, or it will close without producing an action at all.

A does not contain deferrals. When ψ reads q and finds it below the confidence threshold for autonomous emission, it produces a deferral record — naming the candidate, the reason for deferral, and the conditions under which ψ should re-evaluate — but it does not emit. The deferral record lives in the action-control layer.

A does not contain policy-blocked attempts. When ψ identifies a candidate action whose type is not in the active repertoire, or whose blast radius exceeds a configured limit, or that requires capabilities the agent does not have, the attempt is logged as a block record in the action-control layer and nothing enters A.

A does not contain world effects. The world-state changes an action triggers — an email sent, a host quarantined, a purchase order approved — are the effects of the action. They are not the action. The action is ψ's decision to fire, recorded with full provenance and approval-state at the moment of emission. Effects arrive back in the pipeline later, as new events in E.

What A contains, and only what A contains, is the set of actions ψ has actually emitted. An action a ∈ A satisfies five membership criteria. It is ψ-emitted — it came through the action operator, not through any other path. It is entity-targeted — it names exactly one primary target entity x ∈ X. It is purpose-scoped — it was emitted under exactly one p ∈ P, whose version ν(p) is attached. It is aggregation-grounded — it was produced in response to an action-ready meaning object derived from an α ∈ m; ψ never acts on a raw signal z or a bare meaning vector μ. It is repertoire-conformant — its type is drawn from the action repertoire declared in Ω_p.

The distinction between A and the action-control layer is not a storage preference; it is a structural commitment. A is a faithful record of what the agent did. The action-control layer is a record of what the agent considered. Downstream monitoring, audit, and replay depend on the two being separate. An agent that conflates a queued approval with an emitted action — by admitting control-layer records into A as if they were actions — has corrupted its own committed history.

ψ: the unique bridge

ψ is the only operator that produces elements of A. No other path into A exists. No shortcut from Z or M directly to A is permitted. The algebra is explicit on this point: the action-ready meaning object is ψ's only legitimate input shape; bypassing aggregation by feeding raw signals or bare μ's to ψ is a structural violation.

The word "bridge" in this chapter's title is precise. ψ bridges two different kinds of algebraic object: the accumulated, typed, purpose-indexed directional reading that the Meaning Plane produced, and the committed, type-drawn-from-repertoire, world-affecting decision that the Action Plane records. Before ψ, the algebra's objects are internal — they describe what the agent has observed, asserted, and concluded. At ψ, the agent steps outside itself. The emitted action changes the world; its effects are not algebraic objects the agent controls; they are events the agent will observe in the next pipeline pass.

The unique-bridge framing captures three things at once. ψ is the only bridge (no other path into A). ψ connects accumulated meaning to committed action (not raw events, not individual claims, not bare features — accumulated meaning). And ψ crosses the boundary between the algebra's internal record and the external world.

ψ's signature:

ψ(⟨x, p, α, q, π⟩) emits a ∈ A when emission is authorized; otherwise it returns an ActionControl record or ⊥.

The input is always the action-ready meaning object from Chapter 7. The output is either an emitted action (a ∈ A) or a control-layer outcome (recommendation, deferral, block, approval queue entry). The two output paths are both first-class. ψ that defers is not a failed ψ — it is ψ working correctly, refusing to commit below the confidence threshold.

ψ's body runs four stages in sequence. Confidence dispatch reads q(α) and determines the dispatch path: high q allows autonomous selection from the full repertoire; moderate q routes to a restricted repertoire or a confirmation gate; low q defers immediately, producing a deferral record. The threshold values are declared in Ω_p, versioned alongside ν(p), and consulted at every emission — a cached Ω_p from a prior run is forbidden. Direction reading reads direction(value(α)) and strength ||value(α)|| from the aggregated meaning and identifies which action type in the permitted (possibly restricted) repertoire best matches the situation. Repertoire selection picks the candidate action type from Ω_p's declared repertoire; action types not in the active repertoire are not candidates — ψ rejects them, not the aggregate. Policy enforcement checks the candidate against Ω_p's reversibility, approval, blast-radius, and risk-tier rules. If the candidate passes all checks, ψ emits a ∈ A with full provenance and approval-state recorded. If the candidate fails any check, the attempt is routed to the appropriate control-layer path — approval queue, block record, or escalation — and nothing enters A.

What ψ records

Every action a ∈ A carries twelve projections in its full form. Several deserve attention for what they reveal about the algebra's commitments.

approval_state(a) records how the action was authorized. Its values — autonomous, human-approved, emitted-after-deferral, human-approved-after-deferral, escalated-then-emitted — are not metadata for human reviewers. They are first-class projections that audit, replay, and governance monitoring read. "How many actions fired autonomously last quarter?" reads from A_autonomous ∪ A_emitted-after-deferral. "Which actions required human sign-off?" reads from the union of human-approved, human-approved-after-deferral, and escalated-then-emitted. An action recorded as "autonomous" when it required approval — or recorded as "human-approved" when it fired without input — has a corrupted approval_state, and every governance audit that depends on that field produces wrong results.

α_ref(a) names the specific aggregation whose action-ready meaning object ψ consumed. This is distinct from π(a). The provenance trail π(a) threads back through α, through the contributing signals, through their features, evidence, events, and raw material — the full upstream chain. α_ref is the immediate predecessor link. Together they serve different queries: α_ref answers "what was ψ acting on?"; π(a) answers "what ultimately grounded that decision?".

q_at_emission(a) is fixed at the moment ψ fires and never updated. The aggregation's confidence at emission is not the same as the confidence a reviewer would assign to the same decision later, with the benefit of knowing how the action's effects played out. Preserving q_at_emission makes replay possible: given the same inputs at the same moment, with the same Ω_p thresholds, would ψ have emitted the same action? q_at_emission is what that query needs.

Actions are append-only. Once emitted by ψ, an action is not modified. When subsequent evidence shows an emitted action was wrong, or when its effects need to be reversed, ψ emits an explicit retraction action — an action of a designated retraction type, in A, with an ℓ-lineage edge back to the action it retracts. Silent edits to past actions are forbidden; the prohibition mirrors the append-only discipline that governs K, D, I, and Z. A's record of committed history must be as stable as the evidence base that grounded it.

Ω_p and the policy layer

ψ does not decide freely which actions to emit. It decides within the constraints Ω_p declares for the active purpose. Ω_p is not just a threshold; it is a four-class policy structure that ψ enforces at every emission attempt.

Repertoire declaration enumerates which action types are permitted under p. The repertoire may be hierarchical — a sub-purpose inherits its parent's repertoire and may restrict or extend it. ψ rejects candidate types that are not in the active repertoire. The rejection produces a block record in the action-control layer, not an action in A.

Reversibility classification labels each permitted action type as reversible, partially reversible, or irreversible. Irreversible actions — a payment, a public announcement, a credential rotation — may require additional approval gates regardless of confidence. An agent that fires an irreversible action autonomously without consulting reversibility classification has made an unrecoverable commitment without authorization.

Approval gating declares which action types require human approval before emission. The required level may vary by confidence (at q ≥ 0.95 a type may fire autonomously; at q < 0.95 it may require human sign-off), by entity attributes (actions affecting high-tier entities require more authorization than lower-tier ones), or by argument profile (a non-standard template requires more approval than a standard one). The gating structure is declared in Ω_p, not computed by ψ at runtime; ψ consults, not decides.

Blast radius and risk tiers declare the affected scope of each action type and the risk tier it carries. ψ may refuse to emit an action whose blast radius exceeds a configured limit even if the type is in the repertoire and confidence is high. High-risk-tier actions may require higher-authority approval gates regardless of confidence.

Two structural rules hold across all four classes. First, ψ consults the version-pinned Ω_p at every emission attempt — the version pinned to the active purpose ν(p) — never a cached copy from a prior run. Policy changes take effect only through a new purpose version and apply to subsequent runs, not silently within an active run. This is the policy-side realization of the per-run purpose-fixity rule: within a single pipeline pass, the purpose is fixed and so is the Ω_p it carries. Second, Ω_p violations produce control-layer records, never actions. A candidate blocked by Ω_p is never silently dropped; the block is logged so that monitoring can determine whether the policy needs revision or whether ψ's selection logic is producing inappropriate candidates.

The feedback loop: observable, not retroactive

A is the terminal space in the forward pipeline flow. There is no downstream space the action feeds into. In the system as a whole, A is not terminal: every emitted action generates effects in the world that the agent observes as new events — and those events become the inputs of the next pipeline pass.

The feedback loop closes through E, not through direct re-entry to any other space.

When ψ emits a, two things happen: the action produces its world-side effects (an email is sent, a server is quarantined, a purchase order is approved through the ERP), and a synthetic ActionEmitted event is registered in E. World-side responses to the action — the email is opened, the server comes back online, the supplier acknowledges the order — arrive in E later as ordinary events through the agent's perception channels. Those events then flow forward through the full pipeline: admitted into I under ι, claims formed through κ, context assembled, features computed, signals emitted, aggregations produced, new action-ready meaning objects formed. The cycle completes. A new pipeline pass may produce new actions.

The key constraint is: actions cannot silently rewrite upstream spaces. The framework's invariant is that every change to an upstream space comes through that space's declared producing operator. Events through perception; raw data through connectors; evidence through ι; claims through κ; features through χ; signals through σ; aggregations through Agg. Action effects participate in this discipline through E — they arrive as observable events and flow forward. They do not bypass it by directly mutating K, F, M, or any other space.

This is what the ChapterMap means by "feedback is observable, not retroactively algebraic meaning." When an action changes the world, the change does not retroactively alter the meaning that grounded the action. The original α, its signals, its evidence, its claims — all remain in their spaces, unchanged, as the record of what the agent knew at decision time. The world-state change produces new events, which produce new evidence, which produces new claims, which updates context, which may shift the next aggregation. The past is preserved; the pipeline runs forward.

The pipeline's full forward chain, from the canonical form:

X, P → C_admit → E/D/I → K → full C → F → M/μ → Z/z → m/α → ⟨x, p, α, q, π⟩ → ψ → A → E

Every step is necessary. Every transition is operator-gated. The chain reads from left to right; no step can read from a space to its right within the same pass. The feedback arrow from A to E starts the next pass, not a side channel back into the middle.

Z is event-local. m is entity-level accumulation. A is the agent's committed decision under policy. The chain from raw events to committed actions is one-directional, one-step-per-space, and closed through E.

The failure cascade in A

A's failure modes are consequential in ways the upstream spaces' failures are not, because A's failures affect the world.

Premature emission is ψ firing below the confidence threshold declared in Ω_p — either because the threshold was not enforced or because q was miscomputed upstream. The action fires on uncertain meaning. Its effects may need to be retracted. Retraction is itself an action, in A, with its own provenance trail and approval-state; retraction is never a silent deletion.

Repertoire violation is ψ emitting an action whose type is not in Ω_p's declared repertoire. The agent has taken an action it was not authorized to take. The structural defense is the policy-enforcement stage; failure means the check was bypassed. Because the action is in A with approval_state = autonomous, the audit trail records a committed, unauthorized action — which is precisely the governance failure audit trails exist to detect.

Action on raw signal is the aggregation-bypass failure: ψ is invoked on a signal z, or a bare μ, or a feature f, instead of on an action-ready meaning object derived from an α ∈ m. The action was grounded in an event-local reading rather than an entity-level accumulated picture. This is the most structurally corrosive failure — it looks correct (an action was emitted, it has provenance) but the provenance traces back to a single event rather than an accumulated entity picture. The signal that grounded the action may have been an outlier; the aggregation that would have revealed the outlier was never consulted.

Silent retraction is when an action's effects need to be reversed but no retraction action is emitted. The original action remains in A with no record that reversal was needed. The action-control layer may have a note; A does not. Monitoring reads A for committed history and sees a committed action whose effects were in fact undone — a divergence the framework cannot tolerate.

Feedback failure is when ψ emits a but no synthetic ActionEmitted event is registered in E. The feedback loop breaks. The agent has no record of what its action caused; world-response events arrive in E but are not recognized as responses to anything the agent did. The emission and the feedback registration are required to be atomically committed; one without the other is a half-emitted action.

What the Action plane produces

The Action plane's output is a committed decision with full provenance: a ∈ A, grounded in an accumulated entity-level meaning, constrained by Ω_p, recorded with approval-state, append-only, and connected to the world through the feedback edge to E.

The Meaning Plane produces what is meant. The Action Plane produces what is done. The world produces what happens. And the cycle closes through E.

Every space upstream of A contributed to the preparation. Grounding gave A an entity to act on and a purpose that constrains the action repertoire. Observation gave A evidence it can audit. Interpretation gave A the claims and features that shaped meaning. Meaning gave A the typed, accumulated, purpose-indexed directional reading that ψ translated into a candidate. ψ translated that reading into a committed action that changed something in the world.

The production implementation of ψ's four stages — how confidence dispatch integrates with run management, how multiple entities are orchestrated across pipeline passes, how the approval gate infrastructure is built — belongs to the AgentRuntime, which is the subject of a later volume. What Spaces.md gives us, and what this chapter has traced, is the algebraic account: what ψ takes in, what it produces, what it refuses to produce, and what it does when it neither emits nor refuses but holds for further evidence.

ψ(⟨x, p, α, q, π⟩) emits a ∈ A when emission is authorized; otherwise it returns an ActionControl record or ⊥.

X, P → C_admit → E/D/I → K → full C → F → M/μ → Z/z → m/α → ⟨x, p, α, q, π⟩ → ψ → A → E

The move to Part III

Part II named twelve spaces. For each space, the chapter answered the same set of questions: what kind of object lives here, what produces it, what governs it, what its failure modes are. The spaces are the algebra's ontology — the typed containers that hold what the agent knows, observes, concludes, means, and does.

Part III does not add new spaces. It asks what makes the spaces work: how do objects move from one space to another, what rules constrain that movement, and what happens when the rules are violated?

The spaces tell us what kinds of objects may exist. The operators tell us how those objects are allowed to move.

The algebra has nine operators. Each is a declared, typed function that produces objects in a destination space from inputs drawn from upstream spaces. No other path between spaces exists. An agent that transfers objects across a space boundary without going through the boundary's declared operator has not moved an object; it has inserted something into a space without authorization — and the spaces' governance rules treat unauthorized insertion as a structural violation.

This is why the algebra has no glue. Glue is what connects components when no declared interface governs the connection. The algebra's answer is that every space transition is either operator-mediated or it does not happen. The operators are not implementation details. They are the algebra's constitution.

Perceive: the boundary operation

Before naming the nine operators, the algebra names one operation that sits at its edge: perception.

perceive: ExternalSource → E

Perception is the boundary operation through which external signals — telemetry, webhook payloads, database reads, API responses, user inputs — arrive in Event Space E. Perception is not an algebraic operator. Its domain is ExternalSource, which is not a space in the algebra's twelve-space ontology. It has no CSA-internal source. It crosses the boundary from the world into the algebra; it does not operate within the algebra.

This distinction matters for two reasons. First, perception cannot be type-checked in the same way as the nine operators — the external world's objects are not typed in the CSA sort system, and the agent cannot validate their type before admitting them. What the agent can do is enforce that every raw arrival in E becomes a typed D-element before any further algebraic operation is applied. Second, perception cannot return ⊥ in the algebraic sense — ⊥ is the algebra's signal that an operator's input was malformed. Malformed external arrivals fail at boundary parsing or admission discipline — but not as CSA-internal operator ⊥. ⊥ belongs to the algebra’s operators; the external world’s objects are not typed in the CSA sort system, and the failure point for any malformed input is ι (or the connector’s raw-data schema), not perception.

Perception is named here, before the operators, because many readers will expect it in the list. Naming it as a boundary operation — and explaining why it is not operator number ten — is the chapter's first clarification.

Nine operators, three transformations

The algebra has exactly nine operators: ι, κ, χ, η, σ, Agg, ψ, Π, and Π_admit. Three additional functions appear alongside them in the pipeline — wrap_z, collect, and wrap_ARM — but they are not operators.

The distinction between an operator and a typed transformation is not cosmetic. An operator is the sole producer of objects in one of the algebra's twelve spaces. Operators carry effect types: each can return ⊥ (rejection), and some can return non-emission results (no_reading for η, no_signal for σ) or control effects (hold for Agg; defer, propose, queue, block for ψ). Operators are the only places where the pipeline can halt.

A typed transformation is a total function between auxiliary sorts. It cannot return ⊥. It cannot return a control effect. It does not produce a space-sort object. wrap_z assembles a signal's eleven-field structure inside σ — it is σ's internal packing step, not a separate operator. collect gathers the eligible signal set for Agg — it applies eligibility filters and the temporal window constraint, but it produces no m-element itself. wrap_ARM takes an α ∈ m and constructs the action-ready meaning object ⟨x, p, α, q, π⟩ that ψ consumes — it is a typed packing that reads α's fields without creating anything new in m. These three functions are present in the algebra's formal account; they are not present in the list of operators because they have no effect types and cannot halt.

The four-summand result type

Every operator in the algebra returns one of four things. The Mathematical Core makes this precise with the four-summand result type:

T_o(s) = s ⊕ {⊥} ⊕ N_o ⊕ Op(Ctl_o)

Four summands. The first summand s is the emitted object — a space-sort object of the operator's declared codomain. The second summand {⊥} is rejection: the operator received a malformed or type-incorrect input, halted, and produced no output. The third summand N_o is the operator's non-emission result set: η can return no_reading (the evidence carries no direction — a valid computational result that is not a meaning vector); σ can return no_signal (η returned no_reading, so σ produces no signal). All other operators have N_o = ∅. The fourth summand Op(Ctl_o) is the operator's control effects: Agg can return hold (the conflict-resolution policy declined to emit α); ψ can return defer, propose, queue, or block (the action operator produced a structured non-emission outcome). All other operators have Ctl_o = ∅.

The four summands are not equally weighted. Most operator invocations — in a correctly running, well-configured agent — return the first summand: an emitted object. The other three summands are the algebra's formal account of what happens when operators encounter problems or principled non-emission conditions. The distinction between ⊥ (rejection), N_o (non-emission with a valid result), and Ctl_o (control effect requiring downstream handling) is what makes the algebra's failure accounting precise.

Two distinctions the four summands enforce are worth naming explicitly. First: no_reading and ⊥ are different from η's perspective. no_reading means the computation ran correctly and concluded that the evidence carries no directional reading. ⊥ means the computation could not run — the inputs were malformed, the M_p was unregistered, or the normalization violated. Downstream consumers must distinguish them: no_reading may be a legitimate signal that no action is warranted; ⊥ is a fault. Second: control effects from Agg or ψ are not rejections. A hold from Agg means Agg ran, detected conflicted signals, and invoked its conflict-resolution policy — which declined to emit α pending further evidence. A defer from ψ means ψ ran, read q below threshold, and correctly deferred. Both are the operators working as designed. Neither is ⊥. Downstream systems that conflate hold with ⊥, or defer with failure, will mistreat correctly-functioning pipeline branches.

A short illustration: η can return μ, ⊥, or no_reading; ψ can return a, ⊥, or ActionControl. Two operators, eight distinct outcomes between them — and the distinction between the summands is what makes each outcome interpretable rather than opaque.

The nine operator signatures

The nine operators, in pipeline order, with their typed signatures from Spaces.md §16.1:

Operator	Source	Destination	May also return
Π_admit	C_stageable (prior C)	C_admit	—
ι	D_candidate, X, P, E, C_admit	I	⊥
κ	𝒫(I), Predicate_p, X, P, C_admit	K	⊥
χ	T_F, X, P, C, 𝒫(I)	F	⊥
η	E, X, P, C, 𝒫(I), 𝒫(F)	M_p	⊥, no_reading
σ	E, X, P, C, 𝒫(I), 𝒫(F)	Z	⊥, no_signal
Agg	𝒫(Z), C, P	m_p	⊥, hold
ψ	ActionReadyMeaning	A	ActionControl, ⊥
Π	M_{p₁}	M_{p₂}	⊥

The list below begins not with the first ordinary space-producing move, but with the stage projection that makes ordinary admission possible.

Π_admit — staged context projection:

Π_admit: C_stageable → C_admit

Π_admit projects the prior run's full C (or the agent's initial conditions) into the admission-stage context C_admit, freezing S, H, and Q at their pre-current-run values. This is not a space-producing operator in the standard sense — C_admit and full C are stage types of the same Context space, not separate spaces. Π_admit is the pipeline's cycle-breaker: by stage-typing the context that ι and κ consume, the algebra ensures that claim formation does not depend on the claims it is currently producing. Π_admit enables the forward pipeline's one-directionality.

Evidence admission — ι:

ι: D_candidate × X × P × E × C_admit → I ∪ {⊥}

ι takes a slice of D (the raw data candidate), the resolved entity, the active purpose, the triggering event, and the admission-stage context. It produces i ∈ I or ⊥. ι returns ⊥ when entity resolution fails, when validation fails, or when purpose-scope rules in Ω_p exclude the candidate. ι consumes C_admit, not full C. Supplying full C to ι is a type error (stage mismatch, potentially introducing a lookahead leak) and produces ⊥.

Claim formation — κ:

κ: 𝒫(I) × Predicate_p × X × P × C_admit → K ∪ {⊥}

κ takes a subset of the evidence base, a predicate from the purpose's declared predicate inventory, the entity, the purpose, and the admission-stage context. It produces k ∈ K or ⊥. κ returns ⊥ when supporting evidence is below threshold, when the predicate is not in p's inventory, or when stance assignment is inconsistent. Like ι, κ consumes C_admit — it runs before full C is assembled, because K's output populates C's state component S(x, t, p).

Feature computation — χ:

χ: T_F × X × P × C × 𝒫(I) → F ∪ {⊥}

χ takes a feature type from the declared feature inventory, the entity, the purpose, full C, and a relevant subset of I. It produces f ∈ F or ⊥. χ requires full C — it runs after K has populated C's state component. Supplying C_admit to χ is a type error. χ returns ⊥ when the feature_id is unknown, when inputs are temporally inadmissible, or when computation produces an out-of-type result.

Interpretation — η:

η: E × X × P × C × 𝒫(I) × 𝒫(F) → M_p ∪ {⊥, no_reading}

η takes the triggering event, the entity, the purpose, full C, relevant evidence, and relevant features. It produces μ ∈ M_p, returns ⊥ on rejection (unregistered M_p, normalization violation, dimension mismatch), or returns no_reading when the evidence carries no direction. no_reading is not ⊥. η requires full C; it runs in the Meaning plane, after interpretation is assembled.

Signalization — σ:

σ: E × X × P × C × 𝒫(I) × 𝒫(F) → Z ∪ {⊥, no_signal}

σ takes the same inputs as η and invokes η internally. If η returns no_reading, σ returns no_signal. If η returns ⊥, σ returns ⊥. If η returns a valid μ, σ evaluates confidence q, assembles provenance π, and packages the eleven-field signal. σ also operates in rewrap mode when a certified μ' ∈ M_{p₂} produced by Π is supplied; in rewrap mode η is not re-invoked. σ is the only operator that produces elements of Z.

Aggregation — Agg:

Agg: 𝒫(Z_x ∩ Z_p ∩ Z_window(t, Δ)) × C(x, t, p) × P → m_p ∪ {⊥, hold}

Agg takes the eligible signal set (scoped by entity, purpose, and temporal window), the full C for parameter lookup, and the active purpose as rule selector. It produces α ∈ m_p, returns ⊥ on type violations (mixed M_p inputs, broken provenance), or returns hold when the conflict-resolution policy declines to emit. hold is a control-layer record; ⊥ is a hard rejection.

Action selection — ψ:

ψ: ActionReadyMeaning → A ∪ ActionControl ∪ {⊥}

Where ActionReadyMeaning is the set of well-formed action-ready meaning objects ⟨x, p, α, q, π⟩. ψ produces a ∈ A (emitted action) or an ActionControl record (defer, propose, queue, or block). Malformed inputs produce ⊥. ψ is the only operator that produces elements of A.

Cross-purpose projection — Π:

Π_{p₁→p₂}: M_{p₁} → M_{p₂} ∪ {⊥}

Π re-types a meaning vector from one purpose-conditioned subspace to another. It must be declared per (p₁, p₂) pair; absence of declaration is a rejection condition (⊥). Π does not emit a signal; the projected μ' must be rewrapped by σ under p₂ before it can enter Z.

Invalid composition halts

The pipeline's operator chain is a sequence of type-correct compositions. The forward flow is:

X, P → C_admit [via Π_admit] → E/D/I [via ι] → K [via κ] → full C → F [via χ] → M/μ [via η] → Z/z [via σ] → m/α [via Agg] → ⟨x, p, α, q, π⟩ [via wrap_ARM] → ψ → A → E

Each step's output type matches the next step's input type. The algebra's type discipline catches mismatches at the operator boundary — not at runtime, not in a downstream space, but at the moment the operator receives its inputs.

Seven compositions are explicitly invalid and halt at their operator's input boundary:

Agg ∘ η directly (skipping σ): η produces μ ∈ M_p; Agg consumes 𝒫(Z). μ is not a signal. The composition is type-incorrect; Agg returns ⊥.

ψ ∘ σ directly (skipping Agg and wrap_ARM): σ produces z ∈ Z; ψ consumes ActionReadyMeaning. z is not an action-ready meaning object. The composition is type-incorrect; ψ returns ⊥.

Agg over mixed M_p inputs: aggregating signals typed against different M_p's without an explicit Π rewrap. Agg returns ⊥. The most common invalid composition in practice.

χ invoked with C_admit instead of full C: stage mismatch. χ requires full C. χ returns ⊥.

ι invoked with full C instead of C_admit: stage mismatch with a potential lookahead leak (ι would see claim state that depends on its own output). ι returns ⊥; the leak is surfaced to monitoring.

Π_{p₁→p₂} invoked without a registered declaration: the operation returns ⊥. A purpose pair with no declared Π has no cross-purpose transport channel — the absence of declaration is the statement that no such channel exists.

Composing two Π's into an implicit third: Π_{p₂→p₃} ∘ Π_{p₁→p₂} is legal per-invocation (both Π's must be declared), but it does not automatically register a permanent Π_{p₁→p₃}. Each composed invocation is governed; an implicit emergent cross-purpose channel — one that was never declared — is not a legal composition.

The failure of composition is structural, not accidental. Every invalid composition is caught by the type discipline at the operator's input boundary. The algebra does not produce silently degraded output for invalid compositions; it halts and surfaces the violation. Invalid composition halts; it does not degrade silently.

No glue

The seven invalid compositions above share a common structure: each attempts to move an object from one space to another without going through the operator that governs that transition. The algebra's answer is consistent across all seven: ⊥ at the boundary.

This is what "no glue" means in precise terms. Axiom A1 states it as a governance rule: operators are the only path between spaces. Spaces do not populate themselves. An agent cannot move evidence directly into the claim space without κ. An agent cannot move signals directly into the aggregation space without Agg. An agent cannot fire an action without ψ consuming an action-ready meaning object derived from an α. Every space boundary requires exactly the operator whose declared signature ends at that space.

The practical implication: there is no shortcut. An engineer who wants to insert a claim into K because the claim "seems obvious" from context cannot do so without running κ with a proper evidence subset, a predicate from the purpose's declared inventory, and a C_admit. If κ returns ⊥ on that input, the claim does not enter K. The operator is the gating point.

The deeper implication: the algebra's correctness is structural, not behavioral. An agent built on the algebra is correct not because each of its many components produces the right output at runtime — which would require verifying each component separately — but because the type discipline at every operator boundary prevents the most consequential failure modes from occurring silently. The governance rules that govern each space are realizations of the operator discipline: each says, in prose, what the operator's type signature says in formal terms.

Control-layer outcomes — hold, defer, propose, queue, block — are part of this discipline too. The algebra distinguishes what operators produce (space-sort objects) from what operators decline to produce (control-layer records). A hold from Agg is not a degraded α; it is a typed non-emission result that the control layer receives and handles. A defer from ψ is not a failed action; it is a typed control effect. Control layers hold attempts; spaces hold emitted objects. The algebra honors this at every operator's output boundary.

What Part III develops from here

Chapter 9 has introduced the nine operators as a set, named perception as a boundary operation, distinguished operators from typed transformations, presented the four-summand result type, walked through each operator's signature, enumerated the invalid compositions, and stated the no-glue thesis precisely.

The chapters that follow in Part III develop specific aspects of this operator discipline. Chapter 10 — Failure, Control, and Halting — examines what ⊥, no_reading, no_signal, hold, and the ActionControl outcomes mean for the agent's runtime behavior, and why they are structurally different from each other. Chapter 11 — Purpose, Isolation, and Cross-Purpose Flow — develops the Π and Π_admit operators in detail, including the mathematical account of why cross-purpose transport must be declared and what the non-borrowing theorem guarantees.

The algebraic account of the operators is complete at the end of this chapter. The production runtime mechanics are deferred; the implementation receipts return in Part V. What is complete: the typed signatures, the composition discipline, the invalid-composition list, and the principle that governs all of it. Every space transition in the algebra requires a declared operator. No exception is permitted.

perceive: ExternalSource → E

T_o(s) = s ⊕ {⊥} ⊕ N_o ⊕ Op(Ctl_o)

Π_admit: C_stageable → C_admit

ι: D_candidate × X × P × E × C_admit → I ∪ {⊥}

κ: 𝒫(I) × Predicate_p × X × P × C_admit → K ∪ {⊥}

χ: T_F × X × P × C × 𝒫(I) → F ∪ {⊥}

η: E × X × P × C × 𝒫(I) × 𝒫(F) → M_p ∪ {⊥, no_reading}

σ: E × X × P × C × 𝒫(I) × 𝒫(F) → Z ∪ {⊥, no_signal}

Agg: 𝒫(Z_x ∩ Z_p ∩ Z_window(t, Δ)) × C(x, t, p) × P → m_p ∪ {⊥, hold}

ψ: ActionReadyMeaning → A ∪ ActionControl ∪ {⊥}

Π_{p₁→p₂}: M_{p₁} → M_{p₂} ∪ {⊥}

X, P → C_admit [via Π_admit] → E/D/I [via ι] → K [via κ] → full C → F [via χ] → M/μ [via η] → Z/z [via σ] → m/α [via Agg] → ⟨x, p, α, q, π⟩ [via wrap_ARM] → ψ → A → E

The question the algebra must answer

When a pipeline branch does not emit the object it was computing toward — and especially when the agent does not emit an action — what happened?

There are three different things that could have happened, and the algebra requires that they be distinguished. The first is that an operator received a malformed input and could not proceed — a type boundary was crossed in the wrong direction, or the evidence failed validation, or the entity against which a claim was being formed was not found. The second is that the operator received a well-formed input, ran its computation, and concluded that the material it saw was not sufficient to commit — evidence arrived, was considered, and yielded no direction. The third is that the operator completed its work and the result was a control outcome: a hold, a deferral, an approval request, a queue entry, a block. Each of these ends a branch without emitting an algebraic object, but they end it for entirely different reasons, with different downstream implications, and visible to different parts of the system.

Failure is not one thing. The algebra separates malformed composition, valid non-emission, and control-layer suspension because treating them as the same outcome destroys auditability.

This chapter names each category precisely, traces where it comes from in the algebra's type structure, and explains why the distinctions are not optional.

The prior formulation and what it got wrong

An earlier working formulation of the result type described each operator's output as a three-way coproduct:

T_p(Y) = Y + Failure_p + Op(Control_p)

Here Y is the emission, Failure_p captures everything that does not emit an algebraic object for the wrong reason, and Control_p captures the control-layer outcomes that intentionally withhold emission. This formulation does something useful — it separates "the operator failed" from "the operator chose not to emit" — but it makes a mistake in the Failure_p summand.

Failure_p conflates two things that the algebra requires to distinguish. The algebra's axioms explicitly characterize ⊥ as signaling that "the input was malformed" — the computation never legitimately ran, because the input did not satisfy the operator's type requirements. But no_reading and no_signal signal something different: "the operator considered and did not commit" — the computation ran, examined what it received, and returned a typed non-emission as a positive result. The prior formulation places both inside Failure_p, which means a monitoring system reading that label cannot distinguish "the input was invalid" from "the input was valid and the answer was none."

The canon axioms make the distinction explicit. The canonical result type is therefore not a three-way coproduct but a four-summand coproduct:

T_o(s) = s ⊕ {⊥} ⊕ N_o ⊕ Op(Ctl_o)

The four summands are: the emission, rejection, non-emission results, and control effects. The refinement from Failure_p + Control_p to {⊥} + N_o + Op(Ctl_o) is not a mathematical technicality. It is the type-level encoding of a distinction that every serious agent implementation eventually needs.

Rejection: ⊥

The first summand beyond emission is {⊥}. Every operator in the algebra has it. Rejection fires when the input is malformed — when entity resolution fails, when validation fails, when the predicate falls outside Predicate_p, when the evidence type is incompatible with the operator's expected input sort.

Rejection is the algebra's hard stop. It does not produce a value in the destination space. It does not transform into something that the next operator can use. It propagates.

The propagation rule is called ⊥-absorption: once a branch reaches ⊥, every subsequent operator in that composition chain returns ⊥ without examining its input. The Kleisli composition that structures the algebra's operator chains formalizes this precisely — for effectful maps f and g, (g ∘̂ f)(a) = f(a) when f(a) = ⊥, meaning g is never invoked. This is not a defensive design choice; it is a theorem that drops out of the monad laws. The informal canon slogan is "invalid composition halts; it does not degrade silently." The formal content of that slogan is ⊥-absorption.

Who sees ⊥? Monitoring. A ⊥ in a running branch is not a value the next operator touches — it terminates the branch and surfaces to whatever part of the system is watching operator outcomes. The algebra does not specify what monitoring does with it; it specifies only that monitoring is the ⊥ receiver, and that no downstream algebraic computation sees it.

Two examples of when ⊥ fires: ι returns ⊥ when the entity passed to it cannot be resolved against the registered entity index, or when the evidence is malformed relative to the D-type expected. κ returns ⊥ when the support for the predicate falls below threshold, when the predicate itself is not in Predicate_p, or when stance assignment is inconsistent. In both cases the ⊥ is not a judgment about what the evidence means — it is a report that the input to that step was not what the operator required.

Absorption is branch-scoped, not system-scoped. A ⊥ in one branch terminates that branch, but other independent branches are not made ill-typed by this rejection; only the affected composition chain absorbs to ⊥. If σ is being applied across a signal window and one application returns ⊥, the remaining applications in the window still run. The ⊥-absorption law says that composition halts within the affected chain, not that the entire system stops. This is a precision point that matters for auditability: a run with one ⊥ in one branch and clean emissions everywhere else has not "failed" — it has a typed rejection in a typed location that monitoring can identify and trace.

Valid non-emission: no_reading and no_signal

The second non-emission summand is N_o: the operator's non-emission results. Two operators in the algebra have non-empty N_o.

For η, the interpretation operator: N_η = {no_reading}. When the evidence carries no direction — when it is well-formed, passes validation, is associated with the right entity and purpose, but contains nothing that would move the agent's meaning state in any direction — η returns no_reading.

For σ, the signalization operator: N_σ = {no_signal}. Ordinary σ is the composition σ = wrap_z ∘̂ η: it invokes η, and if η returns no_reading, σ catches that and transforms it into no_signal. This is the only in-band non-emission propagation the algebra has. No other pair of operators has a rule that transforms one operator's non-emission into another's. The rule is specific, named, and total — there is no ambiguity about what happens when η returns no_reading inside σ.

The critical thing to understand about no_reading and no_signal is what they are not. They are not failures. They are not rejections. They are positive computation results — the algebra calls them exactly this: "the operator considered and did not commit." The operator ran. It looked at what it received. It determined that there was nothing to say. That is a legitimate, well-typed outcome.

The downstream behavior of non-emissions is locally terminal but globally non-blocking. When η returns no_reading, σ catches it and transforms; no M_p value is produced. When σ returns no_signal, it contributes nothing to the signal set Z — collect assembles the remaining signals, smaller by one. The run continues. If every σ invocation in a window returns no_signal, collect may assemble an empty eligible signal set. That case is still not ⊥: it is an aggregation input condition to be handled by Agg's declared aggregation policy, not a malformed signalization result. At no point does a no_signal halt the branch the way ⊥ does.

This is the distinction the prior Failure_p formulation could not make. An agent system that logs no_reading as a failure has lost the information that the evidence was well-formed and processed correctly. An agent system that logs it as a success has conflated it with an emission. The N_o summand forces the right label: non-emission, considered-and-not-committed, valid.

Control-layer outcomes: hold and ActionControl

The third way to end without emitting a space object is the control-effect summand: Op(Ctl_o). Two operators in the algebra produce them.

For Agg, the aggregation operator: Ctl_Agg = {hold}. When Agg's conflict-resolution policy examines the aggregated signals and declines to emit a meaning vector — because the signals are anti-aligned beyond what any declared policy can resolve, or because the policy explicitly requires escalation — Agg returns hold. Hold is not produced on malformed input (that is ⊥). Hold is not the signalization-level absence caused by no_signal; it is an aggregation-level policy/control outcome. It is produced as a deliberate policy outcome after Agg has run its full internal procedure: collect, dedup, closure check, eligibility filter, decay, conflict policy. Hold is the last step's output, not a shortcut.

For ψ, the action selection operator: Ctl_ψ = {defer, propose, queue, block}. These four together constitute ActionControl. When a well-formed action-ready meaning arrives at ψ and the conditions for direct emission are not met — the action requires approval, must be queued, the agent lacks the right to execute it alone, or a block rule fires — ψ returns one of the four ActionControl records. The records are typed; each record specifies the required resolution path for the surrounding control layer.

The key structural fact about control effects is this: control outcomes are not carrier values of CSA spaces; they are handled operations in the surrounding control layer. An ActionControl record is not an action. It is not an element of A. It is not an emitted algebraic object that travels downstream through the operator chain. The Kleisli category is built over the monad generated by the first three summands — emission, ⊥, and non-emissions. The fourth summand is an effect signature in the sense of algebraic effects: something whose handling lives outside the category, in whatever control infrastructure the deployment provides.

This dissolves, structurally rather than by argument, a question that non-algebraic systems invariably generate: is a hold a kind of failure? Is a defer a kind of partial success? These questions are ill-typed. Hold and defer are neither values in the carrier spaces nor failures at the algebra's type boundary. They are effects that request external handling. Once resolved externally, any continuation arrives as a fresh invocation of the algebra — starting over, with new context and a new purpose-run, not as a continuation of the halted branch.

The downstream behavior of control effects is branch-terminal with external resumption. When Agg returns hold, that branch is done — no m_p is produced, no ARM is assembled, no ψ is invoked for that branch. The hold exits to the aggregation control layer. When ψ returns a defer, the branch is done — no action is emitted, no feedback enters E. The defer exits to the action control layer. Any continuation after the external decision arrives is structurally identical to any other fresh invocation of the algebra.

What halts and what does not

Three things can end a branch without emitting the algebraic object the branch was computing toward. The chapter has now named all three. It is worth stating what each one says about the branch it ends.

Outcome	Means	Not
emission	object entered destination space	control attempt
⊥	malformed boundary / rejection	"no signal"
no_reading	η considered and found no direction	failure
no_signal	σ produced no Z because η had no reading	hold
hold	Agg control effect	degraded α
ActionControl	ψ control effect	emitted action

⊥ says: something about this input was wrong at the boundary. The branch was never legitimate. Monitoring receives the location and reason.

no_reading / no_signal says: the evidence arrived, was processed, and contained nothing to commit to. The branch concluded correctly. The run continues with a smaller upstream contribution.

hold / ActionControl says: the algebra completed its work up to this point and produced a typed control request. The branch is suspended pending external action. A fresh invocation will follow.

These are not three levels of failure severity. They are three different kinds of event that the algebra treats differently because they mean different things. Auditability depends on keeping them apart. If all three are logged as "no output," the monitoring layer cannot distinguish a type error from a deliberate abstention from a pending human approval. If all three are treated as errors requiring retry, the system will retry legitimate control-layer outcomes that were never errors. If all three are treated as success, the system will silently absorb type errors.

The four-summand result type is the algebra's mechanism for ensuring these distinctions survive every layer of the system, from the type-checker to the audit log.

Why the algebra forces this

An untyped system can represent all outcomes as a single result field containing a string. The string can say "success," "error," "no_signal," or "deferred," and the system can do whatever its implementation does with those strings. The algebra's requirement is more demanding: every operator's result must occupy exactly one summand, and the downstream behavior of each summand is fixed by the composition law.

This means the algebraic discipline does not only help with monitoring and auditability — it makes certain mistakes ill-typed. A system that routes no_signal to the monitoring path for ⊥ has made a type error — it has sent a value from N_o to a handler designed for {⊥}. A system that treats hold as a no_signal and contributes an absent entry to Agg's signal set has confused a control effect with a non-emission. The type system catches both before the audit log does.

The algebra's no-glue thesis (from Chapter 9) is what makes this discipline possible. Glue moves results between components without declaring their types. An algebra without glue means every result that moves between operators has a declared type, and the declared type determines the downstream path. The five outcome categories — emission, rejection, no_reading, no_signal, and control effects — map to five declared downstream paths: composition proceeds, monitoring receives, σ transforms, collect assembles without it, control layer handles. No sixth path exists.

The chapter's thesis is now precise: failure is not one thing because the algebra provides four typed summands, not one. Treating them as the same outcome is not a monitoring policy decision. It is a type error.

The question this chapter answers

Suppose a Sales purpose, running over its own evidence, concludes that an account is urgent. Down the hall, a Support purpose is handling the same customer. Can Support inherit Sales's urgency? Can the conclusion "this account is urgent" — formed under one purpose, against one body of evidence, for one reason — simply become a conclusion that Support now holds?

This is not an idle question. The whole appeal of running many purposes over shared infrastructure is that they see overlapping worlds. Sales and Support touch the same accounts; a Finance purpose touches them again. If conclusions leaked freely between them, the system would be efficient and untrustworthy at once: no one could say whose judgment any given decision rested on. And the failure would be silent. Nothing would announce that Support's "urgent" was really Sales's "urgent" wearing a different badge.

The algebra's answer comes in two halves, and the rest of this chapter is those two halves made precise. Support may observe what Sales did — Sales took an action, the action had consequences in the world, and those consequences are visible. Support may not borrow what Sales concluded — not unless someone has declared, explicitly and in advance, that this particular crossing is allowed. Observation is not cross-purpose transport. Borrowing is gated. The gate has exactly one mechanism, and it is locked by default.

Meaning is fibered by purpose

The reason borrowing needs a mechanism at all is structural, and it was fixed back in the spaces. Meaning in CSA is not a free-floating quantity. Every meaning value carries a purpose index: there is no bare μ that means something in general. The meaning space M is a disjoint union of purpose-conditioned fibers — one fiber M_p for each purpose p — and there is no purpose-free meaning value that can be read independently of its p.

This is axiom A11, no-meaning-without-purpose, seen from the typing side. Interpretation enters a fiber only at η, and η emits into the fiber of the purpose whose run it belongs to. No operator rule takes a value in M_p and hands back a value in M_{p′}. The fibers are not layers of one shared object that you can re-index at will; they are separate by construction, and the separation is the default state of the system.

That last point is worth dwelling on, because it inverts a common intuition. In a glued system, a conclusion is just data — a record, a row, a float — and data goes wherever a caller passes it. Isolation, in such a system, is a feature you add: access controls, tenant boundaries, careful plumbing. In the algebra it is the other way around. A Sales-conclusion is not even expressible as a Support-conclusion, because it lives in a different fiber and no typing rule rewrites its index. Isolation is not bolted on. It is what you get when you do nothing. To make a conclusion cross, you have to do something specific — and the algebra gives you exactly one thing you can do.

Observe versus borrow

Before naming that one thing, we have to be careful about what isolation does not forbid, because this is where most of the confusion lives. CSA allows observational coupling; it forbids unauthorized meaning borrowing. Those are different relationships, and collapsing them is the single most common mistake about purpose isolation.

Here is observational coupling. A purpose p selects an action and emits it; the action affects the world, and later perception may admit its consequences as events in E, the observation space. E is purpose-free — it is the shared boundary where the world's arrivals land, including the system's own actions coming back as observed consequences. A second purpose p′, running later, may admit that event as evidence, form its own claims about it, and interpret it through its own η. Sales acts; the action changes something a customer sees; Support observes the change and forms its own view of what it means. The two purposes are now coupled — p′'s state depends, causally, on what p did. But no meaning crossed. p′ derived its own μ through its own interpretation of a shared world. This loop, action to observation to the next run's evidence, is sanctioned explicitly by the algebra (it is the one feedback shape A3 permits), and it is not a hole in isolation. It is what it looks like when an action becomes observable.

Borrowing is the other relationship, and it begins only when meaning from p enters as meaning into p′ — when a value in M_p arrives in a p′-typed object's interpretation without p′ having interpreted anything. That is the move the algebra refuses to perform for free. It requires Π, the cross-purpose projection, and Π is defined only where an authorization exists.

It follows that the isolation guarantee is a non-borrowing guarantee, not a non-interference guarantee in the security-theory sense. The algebra does not promise that p′ can learn nothing about p. A patient observer of Sales's actions might, over time, statistically reconstruct something that looks like Sales's view of an account. The algebra permits this, and is honest about it: the reconstruction is p′'s own meaning, built through p′'s own η, and it shows up in p′'s own provenance as such. What the algebra guarantees is that no value will ever carry p's interpretation while wearing p′'s type. The promise is about provenance honesty — whose judgment is actually in play — not about blocking inference.

Π, the one door

The one thing you can do to move meaning across a fiber boundary is invoke Π. Chapter 9 listed it among the operators; here is what governs it.

Π is the sole cross-fiber term former. Its signature takes a value in one purpose's meaning fiber and produces a value in another's, and its typing rule has a single gate: Π_{p→p′} is defined if and only if the edge p→p′ is declared in the authorization structure 𝒜. Invoke it on an undeclared pair and it returns ⊥ — the rejection outcome of Chapter 10, a malformed boundary crossing, not a quiet no-op. There is no second route. The fibers have one door between any ordered pair of purposes, that door is Π, and the door is locked unless 𝒜 names it.

This is the no-glue thesis applied to purposes. In a glued system there is always another way: a shared cache, a global, a helper that reads one tenant's state and writes another's. The algebra has no such back channel because meaning has nowhere to flow except through a typed operator, and the only typed operator that changes a purpose index is Π. Close that door and the fibers are sealed. Open it — by declaring an arrow — and you have opened exactly the crossing you named, and no others.

Declared arrows, paths, and the two kinds

The authorization structure 𝒜 is a registry of declared projection arrows. Each arrow carries an axis-mapping table — how the source purpose's meaning axes map onto the destination's — a handful of defaults for axes that do not map, and a version reference so the declaration can be re-checked when either purpose's meaning schema changes. Declaring an arrow is the governance act that opens a door.

Arrows come in two kinds, and the distinction is a governance one, not a mathematical flourish. A direct arrow is an authorization with its own justification: it says "p may project to p′ this way," it carries a policy reason for existing, and its mapping is allowed to be anything the policy wants — it need not agree with any other route. A composite arrow is a declared composition: it says "the crossing p→p′ is exactly the crossing p→q followed by q→r," it names the arrows it is built from, and its mapping is checked mechanically at declaration time against the chained mapping of its parts. If the two agree, the composite is coherent and admitted. If they do not, the algebra refuses to call it a composite at all: it is either an incoherent declaration, rejected, or it must be re-declared honestly as a direct arrow with its own justification. This is the no-masquerading rule — a crossing may not present itself as the composition of a path while quietly doing something the path does not do.

Two more facts keep this from sprawling. First, a path is not an arrow. If p→q and q→r are both declared, you may invoke them in sequence, per invocation, to carry meaning from p to r — but the standing arrow p→r is never minted automatically just because the path exists. Composition in the purpose base is itself something you declare, not something the system infers. (The structure that makes this precise — 𝒜 as a partial category, a paracategory, where composition is defined only where a composite has been declared — was settled in the Mathematical Core; for this chapter the result is enough and the machinery can stay there.) Second, at most one composite may be declared per factorization: composition, where it is defined, is a function, not a menu. The practitioner's version of all this is short. A direct arrow is an authorization with its own reason. A composite arrow is a declared composition, coherence-checked. A path is an invocable sequence, never an automatically minted standing arrow.

What the theorems actually say

Two results from the proved suite turn this discipline into a guarantee. Both can be stated in plain language; their proofs live in the Core.

The first is Purpose Isolation (T2). In any conformant run of the system, no p-meaning ever appears in the meaning of a p′-object unless p can reach p′ through declared arrows. The careful word is reach. The guarantee is quantified over paths, not over single edges — and it has to be, because the edge-level version would be false. Take the specification's worked example: three purposes p1, p2, p3, with declared arrows p1→p2 and p2→p3, and nothing declared directly from p1 to p3. Meaning originating under p1 can legitimately end up inside a p3-typed object, by being projected p1→p2 and then p2→p3, each step a real declared crossing. The pair (p1, p3) was never declared, yet the influence is authorized, because it travels a declared path. So isolation is bounded by what the declarations make reachable, not by the raw list of declared pairs.

The second is Transport Soundness (T7), the converse direction. Every cross-purpose influence that does carry meaning is realized by such an authorized path: each step a declared edge, invoked as its own operation, with the meaning re-wrapped under the destination purpose and the version references matching at every hop. And the availability runs both ways — for any pair the declarations make reachable, transport is possible (subject to per-arrow policy); for any pair they do not, it is impossible. Put the two theorems together and the boundary is exact. Meaning crosses along authorized paths, all of them and only them.

𝒜 versus Reach(𝒜): two questions, two tools

This gap between what was declared and what those declarations make possible has a name. 𝒜 is the set of arrows you wrote down. Reach(𝒜) is everything those arrows can reach by chaining — the influence boundary the declarations actually imply. The p1→p3 example is the whole point: (p1, p3) is in Reach(𝒜) but not in 𝒜. Governance cannot answer "who can influence whom" by reading the declaration list, because the list understates its own consequences. It has to compute the closure.

That computation is one of two distinct audit questions, and the algebra keeps them apart. One question is actual and looks backward: how did this specific action arise, whose meaning is in its provenance? That is answered by walking a recorded trace — every Π crossing is its own node in the trace by construction, so the path any real influence took is readable off the record. The other question is possible and looks forward: which purposes could influence which at all, under the current declarations, whether or not it has ever happened? That is answered by computing Reach(𝒜) from the registry. The first is csa trace; the second is the purpose-reachability audit.

A boundary has to be stated plainly here, and it is the chapter's one hard limit. That audit examines possibility. In the present system it has little to chew on: the projection registry is empty — zero declared arrows — so Reach(𝒜) is empty and no purpose can influence any other through meaning at all. No production projection has been exercised; the first real arrow is named future work, not a result to report. What exists today is the discipline and its tooling: the registry format, the declare-time coherence and uniqueness checks, and the reachability audit, built and tested, waiting for the first arrow a deployment chooses to declare. The claim of this chapter is about the shape of the guarantee, not about a crossing that has occurred.

Isolation is the default; transport must be declared

Stand back and the design is one sentence long. Meaning is fibered by purpose; nothing crosses a fiber boundary but Π; Π crosses only where an arrow is declared; and observing what another purpose did is never the same act as borrowing what it concluded. Everything else — arrow kinds, paths, reachability, the two audits — is bookkeeping in service of that sentence.

The practical consequence for anyone building on this is concrete. If you want Support to use Sales's conclusions as conclusions, that is not a query you write; it is an arrow someone declares, justifies, versions, and submits to a coherence check — and once it exists, an audit can show precisely which purposes can now reach which. Until then, Support can watch everything Sales does in the world and must form its own view. Silence in the registry means isolation. That is the safe default, and it is the default you get for free. The opposite of an algebra is glue, and glue is exactly what would let one purpose's urgency seep into another's without anyone deciding it should. The algebra does not forbid that crossing by policy. It makes the unauthorized version of it ill-typed.

The question this chapter answers

A print job fails. The system recorded that it failed — but a month later, the question that matters is not "did it fail" but "how did the system reach that conclusion, and can I reproduce the reasoning exactly?" Which printer events and job-state observations, admitted in what order, run through which operators, produced the claim that this job failed? If the only answer is "the log says it failed," the conclusion is not auditable. You are trusting a summary, not a derivation.

This chapter is about the structure that makes the second question answerable. CSA keeps one primary record of how every conclusion came to be — the trace — and the algebra guarantees that this record can be reconstructed in full, deterministically, from the append-only history and the run/version records the system is required to preserve. Auditability in CSA is not a logging feature bolted onto the side. It is a property of the algebra: the history is append-only and the operators are deterministic, and those two facts together mean the entire derivation behind any conclusion can be replayed.

This chapter closes Part III, and it closes a thread that ran through it. Chapter 10 insisted that documented absence — a rejection, a no-signal, a hold — is a typed outcome the system must keep, not discard. This chapter shows where it is kept: documented absence lives in the trace itself.

The trace is primary

The trace, written Tr, is the primary provenance structure in CSA. Everything else in this chapter is a view derived from it. Tr is a directed acyclic graph at the level of operator invocations. Each node is one invocation, and it carries everything needed to understand that step: which operator ran, in which run frame, on which typed inputs (identified by object identity), under which rule and registry versions, and what it returned. Each edge is a dataflow dependency — from the invocation that produced an object to the invocation that consumed it — including edges that cross between runs when a later run reads a carrier an earlier run emitted.

Two inclusions in that definition are deliberate, and both matter here. First, invocations that rejected their input or emitted nothing are still nodes. A κ that returned ⊥ on malformed evidence, an η that returned no_reading, an Agg that returned a hold — each consumed a real input and produced a typed result, and each is recorded as a node carrying that result. This is the payoff of Chapter 10's discipline: the algebra separates the kinds of non-emission precisely so that, here, they can be written into the provenance record as what they were. Documented absence is documented in the trace, not only in a monitoring side-channel. Second, control-effect nodes carry a reference to their control record, so the trace can be joined to the surrounding control layer without pretending the control record is a carrier value.

The trace is acyclic for two reasons: within a run because evaluation is well-founded, across runs because time orders them. There is no cycle to chase — which is part of what makes replay tractable.

Four views, every one of them lossy

You rarely read a raw DAG. You ask it questions, and each kind of question is answered by a different view of Tr — and every view is a forgetful projection, a quotient that discards something on purpose.

The term tree forgets object identities and results and keeps only the operator structure: the type-level shadow of a run. The event log is any topological serialization of the trace into a sequence — and this is the view to be careful about, because it is the one people instinctively call "the log" and treat as the truth. It is not. A log is a presentation of Tr, not Tr itself; two valid logs of the same trace differ only in the order of independent entries that could have been written either way. The system's append-only log stores such a serialization, and the trace is recovered from it. The log serves the trace, not the other way around.

The provenance cone of an object is the sub-DAG of everything backward-reachable from the node that emitted it — its complete causal history. This is the formal referent of the provenance component every object carries under axiom A10: an object's provenance is the cone behind it. The provenance polynomial is that cone with order and sorts quotiented away — joint use within an invocation becomes multiplication, alternative derivations become addition, each source-level input becomes an indeterminate. It is lossy by design: it deliberately forgets the stage order the cone retains.

That last view earns its keep through a result worth stating plainly. Once you have the polynomial, you can evaluate it in any commutative semiring without recording anything more. Confidence under a weakest-link rule, the cost or latency of the cheapest derivation, the clearance required to view a conclusion — these are not separate logs you maintain. They are evaluations of the one polynomial under different arithmetics. A purpose's confidence calculus is a choice of semiring and valuation, not a feature of the trace. On the worked seed this is literal: a purpose whose rule is "the confidence of an aggregate is the minimum of its parts" is reading the fuzzy semiring off the cone, and the number falls out with no extra machinery. You record the derivation once; the many questions are answered by evaluating it, not by logging more. Only two kinds of question — exact stage order, and typing — exceed what a commutative semiring can see, and both are answered on the full trace, which keeps both.

Putting the views together gives the chapter's working claim: each audit question has a layer that answers it, and moving between them needs no richer recording. Which invocations ran, in what order, with what intermediate results? — read the full trace. What source material contributed, regardless of order? — read the polynomial. How confident, how costly, at what clearance? — evaluate the polynomial in the matching semiring. Why is there no object here? — find the non-emission or rejection node, which exists precisely because the trace records documented absence rather than silence. (Two further questions — whether each cross-purpose step was authorized, and which purposes can influence which at all — belong to the authorization layer of Chapter 11.) One structure, recorded once; many questions, each answered by the right projection of it.

When lineage breaks

A cone is only useful if it is complete. A single dead reference anywhere behind an object truncates its cone, and the object becomes un-auditable: you can no longer say where it came from. CSA's response is not an exception handler bolted on; it is the same partiality that runs through the whole algebra. An object with an incomplete cone falls outside the domain of the action-relevant operators — nothing aggregates over it, no action is derived from it — until its lineage is restored or it is explicitly archived. Auditability is not advisory here. An object the system cannot explain is an object the system will not act on.

Replay: the reconstructibility theorem

All of this would be passive bookkeeping if the trace could only be read forward, as it happened. The result that makes it an audit substrate is T5, Trace Reconstructibility, and its content is this: given the recorded run frames, the input observations (recoverable from the append-only carriers), and the pinned registry versions, deterministic replay reproduces the entire trace — same DAG, same operators, same dependencies, same typed results, including every rejection, non-emission, and control-effect node.

There is one precise qualifier, and it is the honest one. Replay reproduces the trace up to a unique identity-isomorphism — the structure is identical, but freshly minted object ids may be renamed by a single consistent relabeling over the fixed inputs. The reason is that evaluation never depends on a concrete id: rename them all consistently and every step commutes. The practical strengthening follows at once. If the invocation log records the ids it emitted, or mints them in a replay-stable way, that isomorphism collapses to the identity and replay reproduces the trace node-for-node. The engine's log records ids, so the deployment gets the node-for-node form; the general theorem is the weaker isomorphism statement, and the stronger one is a discipline you opt into.

One non-claim has to be stated, because the tempting stronger version is false. The append-only carriers plus the control stores do not, by themselves, suffice to reconstruct the trace. Rejected and non-emitting invocations append nothing to any carrier — yet they are trace nodes. They return not because they were stored but because replay regenerates them: determinism means the same malformed input is rejected the same way the second time. This is exactly why replay, not storage, is the right primitive. You do not keep a copy of every non-event; you keep an append-only history and the ability to re-run it, and the non-events re-occur. The hypotheses are the ones you would expect: state is append-only, evaluation is deterministic, and the registry versions are pinned so the same rules are in force.

The PrintFarm receipt — and its boundary

The theorem is proved in the Mathematical Core. What turns a proof into a lived property is a receipt on real data, and there is one. On the PrintFarm deployment, a frozen baseline of the recorded print-job event log — sixteen events across eleven jobs, three of them terminal, the whole capture pinned by hash — was replayed through the binding and reproduced the on-disk job-state conclusions identically: the comparison returns no differences, and every one of the sixteen admissions is hash-verified and traced. That is a concrete rung-1 receipt for T5-style reconstructibility: the mechanism the theorem describes, exercised end-to-end on a real print farm's history rather than a toy. The proof is the mathematics; this is the instance that shows the mechanism running.

It is worth being exact about what that receipt is and is not, because the slide from one to the other is easy and would be dishonest. What it is: a reconstructibility receipt — the recorded history replays to identical print-job conclusions, failed, completed, printing, with verified payloads. What it is not: a verdict on the field monitor. The camera-frame watcher that decides, from a live video frame, whether a print has actually failed is a separate system on a separate validation track, and it has not graduated. Field receipts exist, but PrintWatch remains in shadow-mode graduation — one of fifteen sessions banked, with the bar set at full recall and a bounded false-positive rate before it is trusted to act on its own. Replaying the event log to identical conclusions says nothing about whether that watcher's judgments are sound. Reconstructibility is not graduation. This chapter claims the first and is silent on the second.

Close

Auditability, then, is not something CSA logs its way into. It is a structural consequence of two commitments the algebra made long before this chapter: the history is append-only, so nothing that happened is overwritten, and the operators are deterministic, so what happened can be made to happen again. Put those together and the trace becomes the ground truth, every other provenance artifact becomes a view you can recompute rather than a record you must trust, and any conclusion can be carried back to the evidence and operators that produced it.

The opposite of an algebra is glue, and glue is what you get when the log is the truth — when the only account of how a decision was made is whatever the system happened to write down at the time. CSA inverts that. The trace is primary, the log is one serialization of it, and the whole derivation can be replayed to identical conclusions from the preserved history and pinned run context. That is the property the PrintFarm receipt demonstrates on real data, and it is the property on which the rest of the system's trust is built.

The question this chapter answers

The Mathematical Core did not make CSA true. It made the commitments already present in the specification precise enough to test, prove, and audit.

That sentence is the whole of Part IV's job, and it is worth saying plainly at the outset because the alternative reading is so tempting. A document titled "Mathematical Core" sounds like the place where the real theory finally arrives and the earlier chapters turn out to have been an informal warm-up. That is not what it is. Everything load-bearing — the twelve spaces, the nine operators, the axioms — was named before this part began. What the Core adds is not new commitments but a formal spine: a language in which the existing commitments can be stated without slack, a proof discipline that can confirm they hold, and a conformance map that can check an implementation against them. This part is about rigor, not revision.

Protective formality, and the layer beneath

The specification the earlier parts drew on defines its objects with what we can call protective formality — enough type discipline to catch an invalid composition at the operator boundary and refuse it. That is real formality, and it does real work; it is what makes the algebra an algebra rather than a set of suggestions. But it stops short of a few things a mathematician would want. It does not give a formal grammar in which the forbidden states are literally inexpressible. It does not present the axioms as typing rules with judgment forms, so that violating one is a type error rather than a convention broken at runtime. It does not pin down which composition laws are CSA's own and which are inherited from standard structures.

The Core supplies exactly that layer, underneath the spec rather than beside it: a formal language, a type system with explicit judgment rules, an effect-typed semantics in which the composition laws fall out of the underlying monad laws, and a provenance semantics for the trace. And it does so under a strict constraint — it introduces no new space, no new operator, no new result kind, no new governance rule. Every symbol it uses is taken from the specification. Where the Core appears to refine something — the four-summand result type of Chapter 10 is the cleanest example — the refinement is a formal articulation of a distinction the spec already drew in prose, with the source cited at the point of articulation. The Core is a deepening of what exists, never an extension past it. That self-restraint is not modesty for its own sake; it is what lets the Core be trusted as an account of CSA rather than a second, competing CSA.

It interprets; it does not edit

A formalization and the document it formalizes can disagree, and CSA has a rule for what happens when they do. The Core never rewrites the specification. If the Core's reading and the spec diverge, the spec wins, and the divergence is logged as a defect rather than quietly smoothed over. The implementation is held to the same order of authority: the engine is evidence, not authority — if the engine and the spec disagree, the spec wins; if the engine and the Core disagree, the disagreement is recorded as a defect against one of the two.

This is enforced by a discipline, not left to good intentions. A locked section of the specification can be amended through exactly one path, and it begins with execution evidence: a failing test, or a port that could not be built as written, recorded in a defect register. That entry is the only legal trigger. An amendment is then drafted scoped to the defect — no opportunistic rewrites of neighboring prose — the section takes a version bump and a one-line changelog naming the defect, and the conformance suite re-runs. Taste, a nicer phrasing, or the Core's own elegance do not qualify; only evidence does. "Locked" therefore means stable until evidence, not frozen. This is the mechanism that lets the Core be written to theory-grade discipline without becoming the authority: it interprets a canon it is not permitted to edit on its own say-so, and every change to that canon has to earn its way in through something that actually broke.

Reducible to none

So what kind of object is the Core — a formal specification, or an independent piece of mathematics? The honest answer is that it sits deliberately between the two, and it says so in an anti-reduction clause. CSA admits faithful interpretations into four established bodies of mathematics. Typed partial algebra supplies the object level — sorted carriers with partial operators. Kleisli composition over an effect monad supplies the failure and control semantics of operator chaining. Provenance semirings supply the projection semantics behind Chapter 12's polynomial. And paracategories supply the structure of Chapter 11's authorization base. Each of these is borrowed openly — cited, and never re-proved.

What none of them imposes is the thing that makes CSA itself: the mandatory pipeline shape. Identity-and-purpose binding at the moment an object is created. ψ as the sole bridge into the action space. Append-only spaces. The staged grounding re-entry that prevents later context from bypassing admission. The specific nine-operator chain and the order it runs in. No theorem of partial algebra or of effect monads forces any of that; those are the axioms CSA adds on top of the borrowed structure, and they are its own mathematical content. This is why the Core is reducible to none of its hosts. It inherits laws where it honestly can — which keeps it from reinventing well-understood mathematics badly — and its original content is precisely the discipline none of the hosts would ever require of you. That is what theory-grade positioning buys: a precise account of what is borrowed and what is new. It is also, importantly, what that positioning does not buy on its own, which is the subject of the next section.

The representation ladder

The strongest claim a formal framework can make about itself is a representation theorem: that its structures characterize, up to equivalence, exactly the systems it set out to model. CSA does not make that claim. What it offers instead is a ladder of three rungs in increasing strength, and it is exact about which rungs it has climbed.

Rung 1 is engine soundness as model checking. The reference implementation's test suite is restated clause-by-clause against the Core's axioms — a forward map from modules to the clauses they exercise, a reverse map from each load-bearing claim to the checks that cover it, and an honest register of the gaps — all of it running in continuous integration. This rung is realized. But it is model checking, not proof: that a particular implementation produces only conformant histories is checked, not demonstrated for all runs, and the Core states this in exactly those words — it is the rung-1 claim, not a theorem of the corpus. Rung 2 is relative consistency: a seed model, built to be distinct from the engine, in which every semantic clause evaluates concretely. It is a witness that the axioms are jointly satisfiable by something other than the implementation that motivated them, and it too is realized in the proof wave. Rung 3 is the general representation theorem — the equivalence theory of models, the claim that CSA's structures characterize agentic systems as such. Rung 3 is named, and named as future work: declared, not promised.

This is the line the chapter must not blur, so it is best stated without hedging. The corpus proved seven theorems; a representation theorem is not one of them, and the Core says outright that the corpus contains none. A proved theorem suite, a clause-by-clause conformance map, and a first external consumer are not a universal theory of agentic systems. They are a great deal — but they are not that, and CSA never claims they are.

How the Core became consumable

The Core did not graduate because the language around CSA became more impressive. It graduated because the formal layer survived contact with use.

The path ran in stages. M0 and M1 forced the reference implementation to carry the twelve spaces, nine operators, result discipline, and invariants as executable structure rather than as prose commitments. That gave the first rung of the ladder its practical meaning: not a proof that every implementation is conformant, but a clause-by-clause model-checking map from the Core to a running engine. B1 and B2 then put that structure under domain pressure. The rule-governed evaluation domain and PrintFarm were not examples added after the fact; they were pressure tests for whether the same algebraic commitments could organize very different kinds of work without quietly changing their shape.

That pressure is what made the consumer requirement non-negotiable. A mathematical core that no tool consumes can still be elegant, but it has not yet proven that it can govern anything outside itself. The purpose-reachability audit mattered for that reason: it was the first external consumer to read the Core's purpose-transport discipline and compute a concrete governance question from it. PrintFarm replay mattered for the neighboring reason: it showed that trace reconstructibility was not only a theorem in the document but a property a real event history could exercise.

This is why the graduation criterion was stricter than "the proofs are written." The Core had to close its proof debts, prove its theorem suite, map itself to the engine, and acquire a consumer. Only then did it become stable enough to rely on. The point was never to make the specification more ornate. The point was to make it consumable without letting consumption rewrite the canon.

What "graduated" means

The Core advanced from draft to canonical on a dated, explicit criterion of four conditions. The proof-debt register had to be empty, or every remaining item explicitly deferred with a named owner. The theorem suite had to be proved at pen-and-paper rigor, including the harder algebraic form of the transport theorem. The rung-1 conformance map had to be real and running in CI. And a first external consumer had to exist — the purpose-reachability audit that computes Chapter 11's influence boundary from the declared authorization registry. The binding sentence behind the fourth condition is blunt: a spec without a consumer does not graduate. All four conditions were met, and the document is canonical.

It is worth being exact about what that word asserts, because "graduated" invites inflation. Graduation means the Core is now stable enough to be consumed; it does not mean CSA has completed its representation theory. Stated to the discipline the Core itself demands, what CSA is is not a complete mathematical theory of all agentic systems. It is a purpose-indexed typed operational algebra with a canonical proof-bearing core and a working implementation. That sentence is the entire claim. It is smaller than the inflated version, and it is the one that will still be true a year from now.

Close

Spec-first is humility with teeth. The Core claims exactly what it proved — seven theorems and a closed register — names the rest as future work, and lets the implementation stand as evidence rather than authority. The discipline cuts both ways: the Core may not quietly fix the spec, and the spec may not quietly absorb whatever the engine found convenient; every change is forced through evidence and written down. The reward for all that restraint is a framework you can trust because it is careful about what it declines to assert. A system that announced itself as the complete theory of agency would be easy to write and impossible to believe. CSA does the harder and smaller thing — it states what it can prove, shows the receipts, and marks the horizon honestly. The opposite of an algebra is glue; the opposite of a theory-grade specification is a manifesto that asserts more than it can test. Part IV is the algebra declining to become a manifesto.

The question this chapter answers

The axioms are not principles the algebra admires. They are the constraints that make a conformant history possible.

An axiom in CSA is a "no" — a thing the system will not do, or will not let happen. And a "no" is only real where something enforces it. A principle written in a document and trusted to good behavior is not a constraint; it is a hope. So the useful question about each axiom is not "is it true?" but "where does its prohibition actually live — and what happens to a run that tries to break it?" This chapter is a reference. It lists the eleven axioms, and for each it answers two things: what it forbids, and where the "no" is enforced. The earlier chapters used these axioms in passing; here they are gathered, and classified by where they bite.

The five places a "no" can live

Before the axioms, the scheme that classifies them. Every constraint in CSA is enforced in one of five places, and the place is the whole point.

Class	What it means	Where it is enforced
TF — term-formation restriction	the violation is unrepresentable; no term of the language denotes it	the grammar
TY — typing rule	representable but ill-typed; rejected as ⊥ at the boundary	the type judgments / operator input checks
SC — semantic condition	a defective interpretation, ruled out of the models	model construction / the state discipline
TC — trace condition	detectable after the fact on the trace; the object becomes un-auditable	the trace and its cones
GV — governance condition	a deployment or registry obligation outside the algebra	declarations, versioning, handler conduct, audit tooling

These categories are cumulative armor, and the framework has a stated preference among them: TF before TY before SC before TC before GV. Push every commitment as far inward as it can be expressed. Inward is better because inward is cheaper and earlier: a violation the grammar cannot express is one no implementation can make; a violation caught at the type boundary fails the same way every time; a constraint left to governance is one a human or a registry must remember to honor. The framework reaches for the outer categories only when the inner ones cannot reach the constraint at all.

The eleven axioms

Most axioms are mixed-class; each names a primary class — the deepest place it is enforced — and may carry supporting clauses in others. The table is for lookup; the fidelity is paid in the entries below it.

#	Axiom	Primary	What it forbids
A1	Operators Are the Only Path Between Spaces	TF	any object entering a space except as an operator's emission
A2	Spaces Hold Emitted Objects; Control Layers Hold Attempts	TY	treating a control record (a hold, a deferral) as an object in a space
A3	One-Directional Within a Run; Feedback Only Through E	SC	an in-run back-edge; feedback re-entering by any route but observation
A4	Append-Only	SC	mutating, deleting, or overwriting a carrier; rewriting history
A5	Invalid Composition Halts; It Does Not Degrade Silently	TY	an invalid composition yielding a degraded result instead of ⊥
A6	No Meaning Without Identity	TY	forming meaning about an unresolved entity
A7	State Conditions Interpretation	SC	assuming an interpretation rule is state-invariant without declaring it
A8	Actionable Direction Enters the Action Plane Only Through Aggregation	TY	reaching an action by any route that bypasses Agg and ψ
A9	Meaning Decays Over Time	SC	weighting a stale signal as if fresh; using arrival time for emission time
A10	Provenance Must Be Preserved	TC	acting on an object whose provenance cone is broken
A11	No Meaning Without Purpose	TY	deriving one purpose's meaning from another's except through a declared Π

A1 — Operators Are the Only Path Between Spaces (TF). The deepest fact about A1 is that "writing into a space" is not a sentence of the language: the grammar has no term former of any space sort except operator application. Its semantic mirror — every interior CSA carrier object is the emission of exactly one producing operator invocation — is needed because implementations have channels the grammar does not govern, and the handler rule H2 closes the last one: a handler is not an operator and cannot emit. Stage discipline (ι and κ typed at admission context, χ/η/σ/Agg at full context) is its typing clause.

A2 — Spaces Hold Emitted Objects; Control Layers Hold Attempts (TY). Control outcomes occur only under the control-effect constructor; no typing judgment assigns a control record a space sort, and control records are not objects. The question "is a hold a kind of action?" is dissolved at the type level rather than answered by policy, and the runtime separation of control stores from carriers is the shadow of that typing.

A3 — One-Directional Within a Run; Feedback Only Through E (SC). In-run evaluation is well-founded — every premise refers to a strictly earlier step, so runs terminate — and the canonical pipeline term has no back-edge to even express. Across runs, the only sanctioned cycle is an action affecting the world, later perception admitting its consequences as events in E, and the next run reading those events as observation; that re-entry is a feedback boundary effect, distinct from ψ's emission into the action space. A3 is a fact about evaluation order, not about which terms exist.

A4 — Append-Only (SC). No mutation term former exists; carriers are monotone over time and control-store resolution state is append-only; retraction and supersession are themselves new emissions, linked to what they replace, never overwrites. Its auditable content is trace reconstructibility — the trace is reproducible by deterministic replay from recorded frames, observations, and pinned versions. The "carriers alone suffice" form is false and is not the claim.

A5 — Invalid Composition Halts; It Does Not Degrade Silently (TY). Every operator's effectful result is total into the four-summand type, with rejection, non-emission, and control effects typed apart; an invalid composition is an ill-typed term. The ⊥-absorption that then propagates the halt is inherited from the monad laws — CSA supplies the typing discipline and the absorption comes for free — and because rejected and non-emitting invocations are trace nodes, the halt is documented absence, visible after the fact rather than silent.

A6 — No Meaning Without Identity (TY). Every meaning-bearing operator position is typed at a resolved entity, and no judgment derives a resolved entity without resolution; the halt-on-unresolved cascade is this rule's runtime failure image. It is the cleanest single-class axiom in the set.

A7 — State Conditions Interpretation (SC). Interpretation's arity includes the full context, so state-dependence is expressible; the interpretation function may map the same evidence, entity, and purpose under different claim-states to different meaning — without threatening determinism, since the variation is across states, never within one. State-invariance of a rule is legal, but it must be declared, never assumed — a governance edge on a semantic axiom.

A8 — Actionable Direction Enters the Action Plane Only Through Aggregation (TY). There is no well-typed term of action sort whose derivation does not pass through aggregation and ψ; applying ψ directly to a signal is ill-typed, ψ has no identity mode, and a singleton aggregation is still an aggregation. The handler rules close the bypass route so the law holds of deployments and not only of terms. This is the axiom that Action Soundness turns into a theorem.

A9 — Meaning Decays Over Time (SC). Aggregation weights each eligible signal by an exponential decay in the time elapsed since the signal was emitted, with emission time authoritative. The algebra fixes the shape of the decay, not its rate: the rate is a per-purpose declaration, and substituting arrival or aggregation time for emission time is forbidden.

A10 — Provenance Must Be Preserved (TC). Provenance-traversability at emission is a well-formedness condition — an object with broken provenance is malformed input and rejects downstream — and identity is primitive and provenance-bearing, so no equivalence may quotient provenance silently. The formal referent of the provenance an object carries is its cone (Chapter 12); an object whose cone is incomplete falls outside the domain of the action-relevant operators. Break handling is partiality, not an exception path bolted on.

A11 — No Meaning Without Purpose (TY). The fiber-introduction rule types every meaning value in its purpose's fiber; no rule derives one purpose's meaning from another's; meaning is a disjoint union, and the sole cross-fiber term former is Π, defined only where its edge is declared. The run frame fixes the purpose for the run's duration, and the authorization registry is a set of declarations whose effective influence boundary — its reachability closure — governance must compute. This is Chapter 11's axiom, seen from the typing side.

What "enforced" means, concretely

Three axioms show how different "enforced" can be. A1 is enforced in the grammar: its prohibition is not a check an implementation might forget, because "writing into a space" is not a sentence the language can form at all — the violation is unrepresentable. A5 is enforced in the type system: an invalid composition is not caught by a guard clause bolted onto the pipeline; it is an ill-typed term, rejected at the boundary, after which the ⊥ propagates by a law the underlying monad already guarantees — get the typing right and the halting behavior is free. A10 cannot be enforced at either of those, because a provenance break may only appear later, when a referenced object has gone missing; so A10 is enforced on the trace, after the fact — an object whose cone is incomplete simply falls outside what the action operators will touch. Three axioms, three different places the same kind of "no" lives. That is what the classification buys: a constraint the grammar cannot hold is held by the types, one the types cannot hold is held by the semantics or the trace, and only what none of them can reach is left for governance.

No axiom is just governance

Read down the primary-class column and one entry is conspicuously missing: not one of the eleven axioms is primarily a governance condition. Governance appears — but only ever as a supporting class, and only in two shapes: parameter supply (the decay rate, the authorization registry, the per-rule state-invariance declarations) and handler conduct (the four rules a handler must obey). Everywhere else the commitment has been driven inward, to a place where the grammar, the types, the semantics, or the trace enforces it rather than a reviewer.

This is deliberate, and it is the spine of the chapter: governance reviews, but implementation enforces. A framework whose guarantees rested on governance would be a framework whose guarantees rested on someone remembering to check. CSA's guarantees rest, wherever the constraint can be reached at all, on the violation being unrepresentable, ill-typed, or un-auditable. Only the irreducibly deployment-specific residue — what your decay rate is, which cross-purpose arrows you have declared, which interpretation rules you have marked state-invariant — is left for a human to review, because only that residue is genuinely a choice rather than a law.

Honest about its gaps

The classification surfaces two more things worth stating, because both are the algebra being honest about itself. First, the two axioms whose primary class is neither term-formation nor typing — A4 (semantic) and A10 (trace) — are exactly the two whose content is about whole histories and traces rather than single terms, and they are precisely the sites of the two hardest theorems in the corpus: trace reconstructibility leans on A4, and the cone-completeness behind Purpose Isolation leans on A10. The classification predicted where the proof work would have to be done.

Second, the algebra is candid about the one place its seed model did not exercise an axiom. A7's non-degenerate case — an interpretation rule that genuinely depends on state — was the only clause the seed left unforced. It was not quietly assumed to hold; it was registered as an obligation and later discharged by an explicit extension that runs a state-sensitive rule and checks that the same event under a different claim-state yields a different meaning. An axiom the model cannot witness is recorded as a debt, and paid as a debt.

Close

The eleven axioms are the price of a conformant history, and the classification is the chapter's real content. Each axiom is a "no," and every "no" has been placed where the system can actually hold it: unrepresentable in the grammar, ill-typed at the boundary, ruled out of the semantics, caught on the trace, or — only when nothing inner can reach it — reviewed in governance. That ordering, inward before outward and enforced before reviewed, is what separates an algebra from a code of conduct. The opposite of an algebra is glue, and a code of conduct is glue with good intentions. The axioms are not principles the algebra admires from a distance; they are the constraints it has made impossible, or ill-typed, or un-auditable to violate — which is the only kind of constraint a system can be trusted to keep.

The question this chapter answers

The earlier chapters showed what CSA forbids; this one shows what CSA can prove — seven theorems resting on six shared lemmas, exactly the suite the semantics supports, and not one statement more.

Parts I through III named the spaces, the operators, and the constraints. Chapter 14 collected those constraints as the axioms — the system's "no"s. But a constraint is only worth as much as the guarantee that follows from it, and this chapter is the guarantees: what the algebra actually proves about any conformant run. It is a map, not a transcript. Each theorem gets its faithful statement and what it buys; the full proofs live in the Mathematical Core. Two things have to be held at once, and they are both the point of the chapter. The suite is a real achievement — seven theorems proved at pen-and-paper rigor, every proof debt closed. And it is deliberately bounded — seven theorems, not a universal theory. The achievement and the boundary are the same fact seen from two sides.

Why the lemmas come first

A proof suite can be a pile of seven separate arguments, or it can be one structure. CSA's is the second, and the lemma library is the reason. Six lemmas are proved once, each establishing a small structural fact, and the theorems are then short because they consume the lemmas instead of re-deriving them. This is not just a convenience for the prover; it is what a reader needs in order to see the seven theorems as one body rather than seven unrelated feats. The lemmas are the shared spine, and the theorems are what stands on it.

None of the six is a headline on its own. One says every interior object has exactly one producing node, so "where did this come from" always has a single answer. One says the wrapping step just before an action copies the action's content verbatim. One says a signal's purpose-label can never disagree with the fiber it actually carries. One says a complete provenance cone stays complete. One says a single run replays exactly from its record. One says a meaning that crossed between purposes leaves a readable trail of authorized steps. Apart, they are plumbing. Together, they are the structure the theorems are proved on — which is why they were proved first, in dependency order, before any theorem was attempted.

The six lemmas

Lemma	What it guarantees	Consumed by
L1 Emission–node bijection	every interior object has exactly one emitting trace node (boundary E/D arrivals excluded)	T1, L4, L6
L2 wrap_ARM preservation	the pre-action wrap is total, effect-free, and copies (x, p, q, π) verbatim	T1, L6
L3 Signal fiber integrity	a well-formed signal's carried purpose equals its typing purpose	T2, T6, L6
L4 Cone-completeness propagation	a complete-cone emission stays complete, and completeness persists under extension	T2
L5 Single-run replay	one run re-evaluates to the same result and trace nodes from its record	T5
L6 Meaning-cone path extraction	a cross-purpose meaning leaves an authorized 𝒜-path readable off its cone	T2, T7

The two heaviest are the cone lemmas, L4 and L6. They are what make the isolation and transport results provable at all: L6 extracts an authorized path from any cross-purpose meaning, and L4 guarantees the cone it reads is complete, so no step of that path can hide. Almost everything hard about Chapter 11's two theorems is discharged in those two lemmas.

The seven theorems

Theorem	Plain-language claim	Anchor
T1 Action Soundness	every actual action was produced by the canonical chain — aggregation, the wrap, then ψ — in one purpose, in-band	Ch 8
T2 Purpose Isolation	no purpose's meaning reaches another's except along an authorized path	Ch 11
T3 No Raw Action	the language itself cannot form an action that was not built from aggregated meaning	Ch 8
T4 Invalid Composition Safety	a rejection halts its own branch, changes no state, and is recorded	Ch 10
T5 Trace Reconstructibility	the recorded history replays to the same trace	Ch 12
T6 Aggregation Closure	aggregating within one purpose stays in that purpose; mixing purposes is rejected	Ch 7
T7 Transport Soundness	every cross-purpose meaning transfer rode an authorized path, and every authorized path is available	Ch 11

T1 — Action Soundness. The careful statement is about actual actions in a conformant history: for every action that exists, there are a unique aggregation and a unique ψ, with the wrap between them, all in one purpose's fiber, and the ψ is in-band — not minted by a handler, and not a resumption of a suspended run. It does not say "every action" loosely; it says every action that was actually produced carries a unique chain, and the in-band clauses are exactly what make even a held-then-approved action sound. What it buys: no action has a mysterious origin. Every one traces back, uniquely and auditably, to the meaning it acted on.

T2 — Purpose Isolation. No meaning typed under one purpose appears in another purpose's meaning cone unless the first can reach the second through declared authorization — and the quantifier is over paths, not edges, because a two-hop authorized path is legal even when the direct pair was never declared. It is a non-borrowing theorem, not a non-interference theorem: a purpose may still observe another's consequences; what it may not do is borrow another's interpretation. What it buys: isolation you can audit — a deployment's influence boundary is the reachability closure of its declared arrows, which is exactly what the audit tool computes.

T3 — No Raw Action. The syntactic twin of T1. Where T1 is about histories, T3 is about the language: no well-typed term can construct an action except through ψ, and ψ accepts nothing that is not a wrapped aggregated meaning. What it buys: the guarantee holds before any run happens. "No raw action" is true of the grammar itself, not merely of observed behavior.

T4 — Invalid Composition Safety. If an operator rejects, three things follow: every downstream step on that branch also rejects — and in the per-item stages only that item's branch dies, the run continuing on the survivors; no carrier and no control store differs on account of the failed branch; and the rejection is itself a trace node. What it buys: failure is contained, stateless, and auditable at once — a rejected branch can neither corrupt the run nor vanish from it. The absorption is inherited from the underlying monad; CSA supplies the typing that triggers it.

T5 — Trace Reconstructibility. Deterministic replay from the recorded frames, the append-only observations, and the pinned versions reproduces the trace up to a unique identity-isomorphism — same structure, same results, with freshly minted ids renamed consistently. Node-for-node reproduction is a corollary, available when ids are recorded in the log or minted replay-stably; the engine records them, so it gets the stronger form. What it buys: the audit substrate of Chapter 12 — any conclusion can be reconstructed exactly, not approximately.

T6 — Aggregation Closure. Aggregating signals that all live in one purpose's fiber yields a result in that same fiber; a set that mixes fibers is rejected at the boundary. What it buys: the one operation that fuses many signals into a direction cannot silently launder one purpose's meaning into another's — it is fiber-tight by construction.

T7 — Transport Soundness. The converse companion to T2: every cross-purpose meaning influence that does occur was realized by an authorized path — each step a declared edge invoked as its own node, re-wrapped under the destination purpose — and conversely, for every reachable pair the transport is available. What it buys: the boundary is exact in both directions. Authorized transport is possible; unauthorized transport is impossible; there is nothing in between.

The proof strategy, in one page

Most of the suite is not proved by inventing seven different tricks. It is proved by reusing five moves.

The first is type-discipline induction, the workhorse. For T1, T3, and T6 — and the fiber half of T2 — the result is forced by the typing rules: you induct over how a typed term was built and show the property holds at every former. The proof is, in effect, "the types already say so."

The second is trace and cone extraction. For T2 you read an authorized path directly off a meaning cone (that is L6), and the cone is guaranteed complete (that is L4), so no step of the path can hide. The geometry of the recorded trace does the work.

The third is branch absorption. For T4, once an operator returns ⊥ the rest of that branch returns ⊥ by a law inherited from the exception monad. CSA does not re-prove that law — it cites it — and contributes the typing that triggers the absorption and the decoration that keeps non-emissions and control effects from masquerading as failures.

The fourth is transport path extraction. For T7, an induction on the length of an authorized path, with the value-map composed per transport segment — the maximal aggregation-free stretch of the path.

The fifth is run-induction replay. For T5, prove that a single run replays exactly (that is L5), then induct over the history's runs in order.

Five moves, six lemmas, seven theorems. The smallness is deliberate, and it is a feature: a suite built from a handful of reused moves is one whose proofs a reviewer can actually check, and a suite you can hold in your head is one you can trust.

What the suite is, and is not

It is worth saying plainly what these seven results are not. They are not a representation theorem. No statement in the corpus claims that CSA's structures characterize agentic systems up to equivalence, and the Mathematical Core says so outright: the corpus is deliberately exactly these seven, and the representation theorem lives on a ladder whose top rung is named future work. Proving the suite does not make the framework the complete mathematical theory of all agentic systems, and the chapter must not let the achievement read that way.

What the suite makes CSA is smaller and more durable: a purpose-indexed typed operational algebra with a canonical proof-bearing core and a working implementation. This chapter is that proof-bearing core, shown. It proves what the Wave-2 semantics can support, and it stops there on purpose — the stopping is not a gap left open by carelessness but a boundary drawn on purpose, with the next rung named rather than claimed.

Close

The earlier parts specified CSA; this one shows it is proved enough to be relied on. That is the move Part IV exists to make — from "here is the algebra" to "here is what the algebra guarantees, proved at pen-and-paper rigor, every debt closed." The seven theorems are not ornament on the specification. They are the reason it graduated, the reason the purpose-reachability audit could consume it, and the reason the earlier chapters' promises — every action audit-able, every purpose isolated, every trace replayable — are guarantees and not hopes.

The opposite of an algebra is glue, and glue is a system whose behavior you can only watch. The seven theorems are the difference: a system whose behavior you can prove, within the bounds it is honest about. Seven theorems, six lemmas, five moves — and not one statement more than the semantics will support.

The question this chapter answers

CsaCore is not proof that the algebra works everywhere; it is the receipt that the algebra runs — a reference implementation whose tests are evidence, clause by clause, that the engine is a model of the Core over the data it has seen.

The chapters before this one made claims about the algebra and settled them against the specification. Those claims are canonical — true by construction of the mathematics, true whenever you read them. This chapter is different in kind. It makes claims about a running program, and a claim about a running program is only as current as the last time someone ran it. So everything here carries a date. Part V is the receipts: what the implementation actually does, verified against the tree, with the caveats a working system always carries. The shift from "proved" to "verified on this date" is not a drop in rigor. It is a different kind of honesty — the kind a running system demands and a theorem does not.

What CsaCore is

CsaCore is the reference implementation of CSA — the engine the earlier chapters' implementation notes were pointing at. It graduated its first milestone, M1, on 2026-06-10: the twelve spaces and nine operators of the algebra realized not as prose commitments but as executable structure, with a test suite that exercises them. The twelve and the nine are fixed — they are counts of the algebra, not of the build — but the suite around them grows as the code does.

As of 2026-06-14, run against this tree in an isolated checkout, the suite reports 255 passed and 48 skipped. That figure is the receipt, and it carries a date for a reason: it is not the number any milestone document records. The conformance map's own header still reads 233 passed; a ledger still reads 239; an earlier note reads 256. Each belongs to an earlier receipt or note, not to this run. The reproducible isolated-suite run on 2026-06-14 is 255 and 48, and where this chapter cites a count, that is the count it cites.

The 48 skips are not failures; they are the suite being honest about what it cannot exercise alone. They are integration tests that need a live environment or a real corpus around them — the deployment regression gate, the baseline-replay checks, the real-corpus checks — and in an isolated checkout, with no environment to read, they skip rather than pretend. A suite that skips what it cannot legitimately run is telling you the truth about its own coverage.

How it got here

The receipt did not arrive all at once; it was earned across a short sequence of milestones, and the sequence is part of the honesty. The first milestone set discipline before code: the rule that no framework object is declared unless something reads it in the same milestone, and the rule that a locked specification section changes only on execution evidence, never on taste. The next milestone built the engine itself and brought its conformance suite green — the twelve spaces, the nine operators, and the axioms running as checks rather than as prose. That is the milestone the phrase "reference implementation" rests on.

The two domain bindings came after, and they are the two in "two domain proofs-of-use." The first reproduced an existing rule-governed evaluation workflow on the engine against a frozen regression baseline — a baseline snapshotted in advance precisely so that "did the engine reproduce it?" had a binary answer rather than a judgment call. The second established replay identity on the print farm: the recorded telemetry, replayed through the engine, reproduces the same job-state conclusions — the receipt Chapter 12 leaned on. Neither domain was chosen to flatter the algebra. One is structured document extraction in a public-sector domain; the other is physical machines emitting telemetry. They were chosen because they are unalike — different enough that one binding organizing both is evidence the structure is not domain-shaped. Two is where that evidence currently stands.

Evidence, not authority

The most important thing to say about CsaCore is what it is not. It is not the authority on what CSA is — the specification is. The engine is evidence, and where engine and specification disagree, the specification wins and the disagreement is recorded as a defect against one of the two. This ordering matters because a working implementation is exactly the thing that tempts you to let code become the definition. CSA declines that. The code is a model of the Core, checked over the data it has seen; it is not the Core.

And "a model over the data it has seen" is the precise, bounded claim — no smaller, no larger. A passing suite shows that on every input the suite presents, the engine behaves as the Core says it must. It does not show that every possible run of every possible deployment conforms. The rung-1 claim is narrower: this reference implementation is checked, clause by clause, over its fixture set. That it conforms over its fixtures is still not a theorem that every deployment does — the distinction Chapters 13 and 15 drew when they called rung 1 a claim, not a theorem. Tests are model checking: they verify the cases they cover. The distance between "these cases conform" and "all runs conform" is real, and the framework names it instead of papering over it. What the suite earns is high, specific confidence over a fixture set built to exercise every operator, every result summand, every axiom, and the seed model's full coverage — not a universal guarantee, and the chapter will not let the green suite read as one.

How the suite maps to the Core

What makes the suite evidence, rather than merely a green light, is that it is mapped to the Core clause by clause, in both directions. The forward map takes each test module and names the Mathematical Core clauses it checks: the invariants module runs one test class per axiom, A1 through A11; the operator-chain module checks the canonical pipeline term and the row-by-row table of invalid compositions; the spaces modules check the well-formedness conditions for each space; the replay module executes the trace-reconstructibility property against a real recorded log; and so on across seventeen modules. The reverse map runs the other way: it takes each load-bearing claim of the Core — control records are not space objects, Π is the sole cross-fiber operation, replay reproduces outputs, a broken cone is excluded from action — and names the tests that check it. Forward tells you what a module is evidence for; reverse tells you that no load-bearing claim has been left unchecked.

The direction is the whole point, and the conformance map states it outright: tests are evidence about the engine, and the Core is the structure they are evidence for — never the reverse. A test does not define a clause; it witnesses that the engine honors one. The map also keeps an honest gaps register — the places where the engine does not yet realize a notion the Core defines — so the conformance is reported, not overstated.

One module is worth singling out, because it marks the first time the Core was consumed from outside itself: the purpose-reachability audit, twenty-three tests, the first external tool to read the Core's transport discipline and compute a governance question from it. Its presence in the suite is what closed the final condition of the Core's own graduation — a specification without a consumer does not graduate.

The boundary

So what does all this license, and what does it forbid? The forbidden claim first, because it is the easy one to drift into. CSA is not proven universal across all agent systems. The evidence base is two domains — a rule-governed evaluation domain and a print farm — and the result that one algebraic binding organizes both is a claim at two, not a claim about all. The honest answer to "does it generalize?" is to widen the evidence: bind a third domain, then a fourth, and let n grow. It is never to relabel two domains as "universal." The number two is not a weakness to be hidden; it is the current state, stated precisely.

The permitted claim is correspondingly bounded, and it has a fixed phrasing this chapter holds to: CsaCore is a working reference implementation with two domain proofs-of-use and early field integration. Not "production-hardened across many organizations" — that would assert an operational maturity the implementation has not earned. "Working" is true: it runs, it conforms over its fixtures, its suite is green today. "Two domain proofs-of-use" is true and counted. "Early field integration" is true and appropriately modest — the print farm is a real deployment, but the field receipts are early and the field monitor is still in shadow mode, exactly the boundary Chapter 12 drew. The phrasing is small on purpose. It is the most the evidence supports, and not a word more.

Close

The receipt, then, is exactly this. As of 2026-06-14, the reference implementation of CSA runs; its suite reports 255 passing and 48 skipped in an isolated checkout; and every passing test is mapped, in two directions, to the clause of the Mathematical Core it witnesses. The algebra is not a document describing a system that might exist. It is a document with a running model attached — checked clause by clause over the data it has seen, on two real domains, today.

That last word is the character of Part V. The canon chapters made claims that hold whenever you read them; this one makes a claim with a date on it, and the date is the honesty. The opposite of an algebra is glue, and the opposite of a receipt is a press release. CsaCore's receipt says what ran, when, and against what: a working reference implementation with two domain proofs-of-use and early field integration — and not a universal proof of anything.

The question this chapter answers

The real test of an algebra is not self-consistency but whether it survives a domain it did not grow up in — and the lesson of the first binding, not the domain's contents, is what this chapter carries.

The chapters before this one built the algebra and proved things about it on its own terms. But a structure can be internally perfect and useless at once — consistent with itself and fitted to nothing real. For a system meant to organize actual work, the question that matters is whether it bends to a domain it was not designed around, or whether the domain has to be bent to fit it. The first binding of CSA to a real, structured domain is where that question got an answer, and this chapter is about the answer and the method, not the domain. The domain is a confidential matter, and its specifics stay where they belong, behind that confidentiality. What travels out is a lesson — which is more portable than a description anyway. A description tells you what happened once. A lesson tells you what to expect the next time.

Why a rule-governed evaluation domain is a good first test

A first binding should be chosen to be hard in the right way, not easy in a flattering one. The right kind of hard is a rule-governed evaluation domain — the category where written criteria are supposed to decide consequential outcomes, and where the inputs are largely documents. (Grant evaluation is one familiar instance of the category; it stands here only as an illustration, with nothing said about any specific program or whose.) A domain of this kind is demanding for three reasons.

It is rule-governed: decisions are meant to follow written criteria, so there is a real standard to be faithful to, not merely a preference to be matched. It is high-stakes: the outputs can affect consequential public decisions, so "roughly right" is not good enough and a silent error is costly. And auditability is not a nicety but an expectation: someone may have to explain, after the fact, why a decision came out as it did.

Those three properties — explicit rules, real stakes, mandatory auditability — are precisely the ones CSA was built to serve. A domain that did not care how a conclusion was reached would test only whether the answers were right; it would leave the algebra's distinctive commitments unexercised. A rule-governed, auditable domain demands something harder: reaching the right answers in a way that can be shown to be right. That is the test worth passing first, and it is why a domain of this kind — rule-governed, evaluative, document-driven — was the right place to start, on the strength of the category alone.

What binding means, at the algebra level

"Binding" is a precise act, and describing it needs no project detail. CSA arrives with no domain's meanings built in; its spaces and operators are domain-neutral by construction. To bind a domain is to supply the domain-specific content the neutral structure requires, and nothing else. Concretely, two kinds of content.

First, the domain's notion of meaning is supplied as a purpose-indexed meaning fiber — the axes along which this domain's judgments vary, the meaning space a purpose in this domain reasons in. An evaluation purpose of this kind might reason along axes like eligibility and merit; binding the domain means declaring those axes as the fiber's coordinates, so that "meaning" here becomes a typed object the algebra can carry, decay, and aggregate. Second, the domain's assertions are supplied as claims — the typed objects that say "this entity has this property, on this evidence, with this support." A claim that an entity satisfies a criterion is not a free-floating fact; it is a typed claim with a provenance, formed by the interpretation operator from admitted evidence, and audit-able back to it.

What is striking — and this is the lesson, not the project — is how little of CSA had to change to receive a real domain. The operators did not change. The axioms did not change. The pipeline did not change. What changed was the supplied content: the fiber's axes, the claim predicates, the eligibility and aggregation policies a purpose carries. The domain plugged into the operators; the operators did not bend to the domain. That is the entire claim of a binding — the algebra is the fixed part, the domain is the parameter. Had the operators needed surgery to accommodate the domain, the binding would have been evidence against the algebra. They did not, and so it is evidence for.

The frozen baseline, as a method

The most transferable thing the binding produced is a method, and there is nothing confidential in it. The problem it solves is ordinary and dangerous: when you port an existing workflow onto a new engine, "did it still work?" is far too easy to answer with a judgment call. The outputs look plausible, the person who built it nods, the port is declared good — and that is exactly how a regression hides.

The method that prevents this is to freeze a baseline before the port begins: snapshot the existing workflow's inputs, its outputs, and the versions that produced them, and lock that snapshot as the definition of "correct." The porting question then stops being an impression and becomes a comparison — given the frozen inputs, does the engine reproduce the frozen outputs? Yes or no, with a recorded answer.

The discipline has two halves, and both matter. Freeze early — before the port, while there is no incentive to nudge the target toward whatever the engine happens to produce. And treat any drift from the baseline as a defect to explain, never a number to quietly update. With a frozen baseline, "it works" stops meaning "it looked right to the person checking" and starts meaning "it reproduced a standard fixed before anyone could be tempted to move it." The binding passed against its frozen baseline. The specific numbers belong to the engagement and stay there; the method belongs to anyone porting a workflow, and it is the part worth carrying out of this chapter.

Two domains, not all domains

One binding proves something narrow and real: that the algebra received this domain without bending. It does not prove the algebra receives every domain. The honest unit of evidence is the number of domains bound, and after this chapter that number is one.

The next chapter raises it to two, with a domain about as unlike a document-driven evaluation as one could choose — physical machines emitting telemetry, where the "evidence" is sensor readings and the "deadlines" are print times. Two bindings, two unlike domains, one unchanged set of operators: that is the evidence that the structure is not secretly shaped like a single domain. And it is exactly two. The discipline from the implementation chapter holds here without change — the answer to "does it generalize?" is to bind a third domain and a fourth, widening the evidence, never to relabel two as "universal." Two is a real claim and a bounded one, and the chapter states it precisely and stops.

Proof-of-use, not an operationalized business

A final boundary, because a chapter about applying CSA to a real domain invites a claim it must not make. This binding is a proof-of-use: evidence that the algebra works on the shape of a real domain. It is not evidence of an operationalized business behind it, a delivered service, or a productized practice. Algentis is, at this writing, a solo founder with the ordinary early-stage scaffolding — legal, payments, a site — still being put in place.

"The algebra bound a real domain" and "the company that owns the algebra is operational" are different claims, and only the first is on the table. Keeping them apart is the same discipline as everywhere else in the book: say what the evidence supports, with a boundary, and not the adjacent thing it is tempting to imply. A binding is a technical result. It is not a balance sheet.

Close

The binding held. Applied to a domain it was not designed around — rule-governed, high-stakes, auditable — the algebra took the domain as a parameter and left its operators, its axioms, and its pipeline untouched. That is the result, and it is a real one.

Everything that made the domain itself — whose it was, what it governed, what its documents said, how well any extraction scored — stays behind the confidentiality where it belongs, and the chapter is not poorer for it, because the portable part was never the specifics. It was the lesson: that an algebra is tested by a domain it did not grow up in; that binding means supplying content to a fixed structure rather than reshaping the structure to the content; that a frozen baseline turns "it works" from an impression into a recorded yes; and that one such binding is one — real, bounded, and waiting for the second. The opposite of an algebra is glue, and glue is what you write when every new domain needs new plumbing. The binding showed the plumbing did not change. The domain did.

The question this chapter answers

If a rule-governed evaluation domain tests whether the algebra can make accountable judgments, a print farm tests whether it can do so in a world that is physical, irreversible, and does not wait — and the honest receipt, dated and bounded, is that it ran, it remembered its failures, and its watcher is still in training.

The previous chapter bound CSA to a domain made of documents, where the evidence sits still and many mistakes can be revisited before they become physical. This chapter binds it to a domain made of machines, where a wrong judgment becomes wasted filament, a ruined part, and an hour that cannot be replayed. It is the second of the two domains — chosen to be as unlike the first as the world allows — and it is where the algebra met physical consequence. The chapter is a set of receipts, and the discipline of a receipt is that it is dated and bounded: it says what ran, when, and how far — and, just as plainly, how far not. There are four receipts here, and the whole of the chapter's honesty is in keeping them apart.

Why physical manufacturing is the stronger test

A document domain is a demanding test of care, but it is forgiving in one respect: time. A misread form can be reread; a wrong score can be revised before it counts; the evidence sits still and waits. A print farm forgives none of that.

A print is irreversible — once the head has laid plastic, a misjudgment is already physical. It is real-time — the decision to let a job run or to stop it has to be made while the machine is moving, not after the fact. And it fails physically — not as a low confidence number but as a warped part, a failed adhesion, a tangle of filament that a camera, not a rulebook, has to notice. These properties make manufacturing the stronger test precisely because they remove the document domain's safety margin. An algebra that organizes accountable judgment when the evidence waits is good; one that does so when the world is moving and the cost is physical has been tested harder.

That is why this was the right second domain: not because it resembles the first, but because it does not. Two domains this unlike — one made of text and criteria, one made of machines and time — sharing one unchanged set of operators is the evidence that the structure beneath them is not secretly the shape of either.

Receipt one: replay identity

The first receipt is the one Chapter 12 already leaned on, and it is the most settled of the four. The print farm's recorded telemetry — the stream of events each job emits as it starts, runs, fails, or finishes — replays through the engine to identical job-state conclusions. The comparison is exact: given the frozen sixteen-event baseline, the engine reproduces every recorded conclusion with no differences.

This is reconstructibility, the property Chapter 12 described, exercised on real machine data: the recorded history replays to identical job-state conclusions, with the derivation traceable. It is frozen and stable — the baseline was snapshotted and hash-pinned, so unlike the others, this receipt does not move. And it is exactly one receipt. That the telemetry replays faithfully says the engine is a faithful model of what the machines did. It says nothing, on its own, about whether the watcher reading the camera is any good, or whether the system dispatched anything by itself. Those are different receipts, and the temptation to let this clean, frozen one vouch for them is precisely what the chapter has to resist.

Receipt two: the failure corpus

The second receipt is field integration: the algebra did not only replay recorded history, it ran on live jobs and built a memory of them — failures included. Three early jobs anchor it.

The first dispatch was operator-invoked — and that qualifier travels with it: a human triggered the job; the system did not choose to run it on its own. The first failure was a real one, a print that did not finish, kept as the start of a failure corpus rather than discarded as an embarrassment. And the first clean finish was the first job to run through to a completed terminal under the system's eye. Since then the memory has kept growing — a second clean shadow session followed, which also validated a fix that closed an idle-tick backlog left over from the first.

The point of the corpus is not that nothing went wrong; it is that what went wrong was kept. A field memory that records its failures as data — typed, dated, replayable — is worth more than one that records only its successes, because the failures are exactly what a watcher will eventually have to be measured against. This receipt is real and it is accreting. And it, too, is distinct from the next one: having a memory of failures is not the same as having a watcher that reliably catches them.

Receipt three: the watcher, still in training

The third receipt is the one most easily overstated, so it is stated most carefully. PrintWatch — the component that reads camera frames and judges whether a print is failing — is in shadow mode. It watches and records its judgments, but it does not act on them; it is being measured against a graduation bar before it is trusted to raise an alarm on its own.

The bar has three conditions: at least fifteen banked shadow sessions, perfect recall on real failures, and a false-positive rate at or below twenty percent. As of the live counter on the drafting date — 2026-06-14 — two of those fifteen sessions are banked. Both were clean prints that finished normally, which means the watcher has not yet faced a real failure during a shadow session, and so its recall is not low, and not high, but undefined: there has been nothing yet to recall. Its false-alarm rate over those two clean sessions is zero.

So the honest statement is not "the watcher works," and not "the watcher is two-fifteenths of the way to working." It is the exact field form: field receipts exist, but PrintWatch remains in shadow-mode graduation. Two of the three conditions are not merely unmet — they are not yet measurable. A book that said otherwise would be vouching for a watcher that has not yet seen the thing it exists to catch.

Receipt four: two domains, not all domains

The fourth receipt is the count itself, and counting honestly is its own discipline. Two domains are bound: the rule-governed evaluation domain of the last chapter, and this physical-telemetry one. Two unlike domains, one operator set unchanged across both — that is the n-equals-two evidence, and it is exactly two. The discipline set in the implementation chapter holds at the close: the answer to "does it generalize?" is to bind a third domain and a fourth, widening the count, never to round two up to "universal."

And every number here is the live, dated one — the watcher counter especially, which moves with every print, so the figure true today is two of fifteen, recorded as of the drafting date and superseding the older one-of-fifteen an earlier note still carried. The receipts do not borrow from one another. Replay identity is frozen and exact. The failure corpus is real and growing. The watcher is in training, its recall not yet testable. The domain count is two. Each is true on its own evidence, and none lends its credibility to the others.

Close

That is Part V, and it is the whole of what the field has earned so far. The algebra ran on real machines, not only on documents and proofs. It replayed their recorded history to the same conclusions, exactly. It kept its failures as a corpus rather than hiding them. And its watcher is honestly, measurably still learning — two shadow sessions banked, no real failure yet seen, no alarm yet trusted to fire on its own.

None of that is a universal claim, and none of it is a press release. It is a set of dated receipts, each bounded by what it actually shows. The opposite of an algebra is glue, and the opposite of a receipt is a story you tell about your system. The print farm gave the algebra something better than a story: a physical world that does not wait, a memory of what went wrong in it, and a watcher whose training is being counted one honest session at a time.

The question this chapter answers

The book did not come before the newsletter; it comes after it — the essays were the public draft where CSA first had to explain itself, and the book is their conversion, with the early arcs written and the later arcs still only mapped.

It is natural to assume a book like this was written first and serialized after — that the chapters came first and the essays were excerpts. The order was the reverse. CSA was explained to the public, week by week, in a newsletter, before any of it was a book; and this book is organized as the conversion of those essays into chapters, not as a serialization of chapters already written. That order is not an accident of scheduling. It is the method. This chapter is about why the public writing came first, what it did to the work, and — honestly — how much of the book is written and how much is still only a plan.

Why the essays came first

There is a discipline a specification cannot impose on itself: the discipline of being understood by someone who did not write it. A spec can be precise and still impenetrable; it can define every term and never explain why any of them matter. Writing for a public reader, on a schedule, removes that hiding place. Each week an idea had to be stated plainly enough that a stranger would follow it and care — and an idea that resists plain statement is usually an idea that is not yet finished.

So the newsletter was not a marketing afterthought bolted onto a completed theory. It was the place CSA first had to explain itself, out loud, to people under no obligation to be patient. The essays came first because explaining-to-others is a different test than proving-to-yourself, and CSA needed to pass both. The formal core — the earlier parts of this book — is where the algebra proves it is consistent; the newsletter is where it had to show it is comprehensible. A theory that is one without the other is half-built.

How public writing shaped the work

Writing in public did more than communicate the work; it changed it — though here a chapter has to be careful, because it is easy to over-claim a tidy story of "the essay revealed the flaw." The honest version is quieter. The act of explaining an idea to a reader who will not accept jargon repeatedly exposed places where a distinction was fuzzier than the spec admitted, where a word was carrying two meanings, where an example did not actually illustrate the claim it was meant to.

Some of those became sharper definitions; some became the very distinctions the formal chapters now turn on. The point is not that the newsletter rewrote the mathematics — the mathematics has its own discipline — but that public exposition and formal precision pulled in the same direction, each catching what the other missed. The proofs caught what was false; the essays caught what was unclear. A claim that survived both was a claim worth keeping. That is why the public draft is not a lesser artifact than the book: it was load-bearing in the making of the work, not a downstream byproduct of it.

The curriculum map

The newsletter and the book share a skeleton, and the sharing is deliberate. The roadmap that plans the newsletter doubles as the book's outline: one series of essays corresponds to roughly one part of the book, and the chapters are revised from the issues, not the issues extracted from the chapters. The first series — the one that named the problem, why agents need an algebra at all — maps to the book's opening. The second — the one that priced it, what the discipline costs, paid one operator at a time — maps to the arc that follows.

The correspondence is a curriculum, not a transcription. A chapter is not a reprinted issue, and not every chapter descends from a specific essay — several of the formal chapters were written from the specification directly. What the mapping guarantees is coherence: that the public draft and the book teach the same things in the same order, without forcing the book to ship on the newsletter's weekly cadence. The roadmap keeps two layers for exactly this reason — a stable skeleton that is the book outline, and a flexing issue queue that bends with reality. The skeleton is the promise; the queue is the schedule.

Laid out in full, that skeleton is seven series, and naming them is the clearest way to show the book's shape — and to stay honest about how much of it exists. The first named the problem: why agents need an algebra at all. The second priced it: what the discipline costs, paid one operator at a time. The third opens on the moment the algebra becomes accountable enough to touch the world; the fourth takes a single interpreter apart; the fifth is about many agents meshing; the sixth is the economics of all of it; the seventh, a system that reads itself. Seven series, roughly one per part of the book. Two of them exist as prose. The other five exist as exactly that list — titles and theses, locked in order — and as nothing written beyond it.

The honest state of the corpus

Now the part a provenance chapter owes the reader: how much of this actually exists. The honest answer has four different degrees of doneness, and collapsing them would be the easy lie.

First, there is published prose: the first series is out, live to the public, all of it. Second, there is completed-but-rolling-out prose: the second series exists as complete issue text and is publishing issue by issue — written, staged, released on its own cadence. Third, there is the conversion itself: this book, the act of turning issue-form prose into chapter-form, which is work in progress and not a finished manuscript. And fourth, there is the plan: the remaining five series exist as locked structure — a curriculum with titles, theses, and, for the next arc, even a locked sequence of issues — but not as written prose.

The roadmap's own discipline states this most precisely. The next series is "editorially designed, but not operationally born": its shape is fixed, but it has not yet entered the prose pipeline. Designed is not born; a locked skeleton is not written text. So the accurate statement of where the book stands is not "the manuscript is done." It is that the raw public prose exists for major early arcs; it needs conversion from issue-form to chapter-form — which is exactly the work this volume is. The road ahead is a plan, not a receipt: the five later series are mapped, not accomplished, and this chapter describes them as intended, never as achieved. That distinction — between what is written and what is only planned — is the same discipline the whole book has insisted on, turned now on the book itself.

Close

The essays came first, and they were not a lesser thing for it. They were where CSA first had to be understood — where the discipline of public explanation pulled the ideas toward clarity while the proofs pulled them toward truth. The book is the conversion of that public draft into a durable form: the early arcs written, the later arcs still only mapped, the whole of it honest about which is which.

That honesty is why this chapter sits near the end rather than hiding the seams. A book that claimed to have sprung into being complete would be asking to be trusted on its packaging. This one would rather show its provenance — a newsletter that came first, a conversion still underway, and a road ahead that is named, sequenced, and deliberately not yet claimed as done. What that road actually leaves unfinished is the subject of the final chapter.

The question this chapter answers

A book earns trust not only by what it proves, but by what it refuses to claim — so Volume 1 ends by naming, plainly, the things it does not yet do, each a boundary the work has reached and not yet crossed.

Every chapter before this one was careful about some claim it would not make: that the algebra is universal, that the field watcher works, that the company is built, that the theory is complete. Those refusals were scattered through the book as guardrails. This chapter gathers them into one place and states them outright, because a book that hides its boundaries asks to be trusted on faith, and this one would rather be trusted on inspection.

There is also a design reason these boundaries exist, and it matters. Volume 1 is algebra-only by design. It set out to do one thing — establish the algebra, prove what can be proved about it, and show it binding to real domains — and to leave the rest for what comes after. So most of what follows is not a list of failures; it is the deliberate edge of a scope drawn on purpose, and naming the edge is how a reader is kept from mistaking the part for the whole. Eight boundaries, in three kinds: where the mathematics has named its own next step, where the system around the algebra is still unbuilt, and where the field and the company are still early.

The algebra's own frontier

Begin with the boundaries internal to the algebra, because the Core named these on its own.

The first is the representation theorem. The book's theorem suite is seven theorems, supported by six lemmas, proved at pen-and-paper rigor — but a representation theorem, the statement that CSA's structures characterize agentic systems up to equivalence, is not among them. The Core places it on a ladder whose top rung is explicitly future work: the lower rungs — engine conformance, and a model distinct from the engine — are reached; the top rung is named, not climbed. A book that quietly let its seven theorems stand in for a representation theorem would be claiming the strongest thing on the strength of real but lesser ones. CSA does not, and says so exactly where the claim would otherwise be tempting.

The second is the first production projection between purposes. The algebra defines Π, the one authorized door between purposes, and proves what authorized transport must satisfy — but in the live deployment, no production Π arrow has ever fired. The authorization registry holds zero declared arrows. (It changed location in a recent restructure; it is still empty.) So the cross-purpose machinery of the isolation chapter is proved, built, and waiting — not exercised. The first real arrow is a milestone ahead, not a receipt behind. These two — the unproved top rung and the unfired arrow — are the algebra's own frontier: where the mathematics has done its part and pointed at what it has not yet done.

The runtime and the economy — later volumes

The next two boundaries are not internal to the algebra at all. They are the layers that would surround it in a full system, and Volume 1 deliberately did not build them.

The first is the runtime. There is a companion specification for the machinery that would actually execute the algebra — the kernel, the schedulers, the wiring between agents — and it is incomplete: several sections await review and re-lock, and two load-bearing ones, including the action-control layer and the first MVP configuration, are explicitly deferred. This book does not draw on that specification for anything. It points at it as unfinished and leaves it there; the runtime is a later volume's subject.

The second is the economic layer. There is a candidate design for how agents in such a system might hold and exchange value — and it is a frozen candidate, declaring nothing, locking nothing, with no live activity. It is a pointer in this book and nothing more. Both of these sit outside Volume 1 by the same decision that made the volume algebra-only: an algebra can be established, proved, and bound without yet building the runtime that hosts it or the economy that might one day run on it. Naming them as unbuilt is not an apology — it is the scope line, drawn where it was always meant to be.

The field and the company — still early

The last group is the distance between a proved algebra with two bindings and a mature, deployed, productized system. Four boundaries, each touched earlier in the book, stated here together.

The field watcher is in training, not graduated. The camera-frame component that judges whether a print is failing watches in shadow mode; as of the live counter, two of fifteen sessions are banked, both on clean prints, so its recall — whether it catches real failures — is not yet even measurable. Field receipts exist, but the watcher remains in shadow-mode graduation.

The binding is proven at two domains, not universally. One rule-governed evaluation domain and one physical-telemetry domain share one unchanged operator set — real evidence that the structure is not domain-shaped, and exactly two domains' worth of it. The honest answer to "does it generalize?" is to bind a third and a fourth, never to call two "universal."

As of this volume's drafting, the company is a venture in its first weeks, not an operating business. Algentis is a solo founder in an early phase — the legal form still an open decision, the public site still a task on a list. "The algebra bound a real domain" is true; "the company that owns it is operational" is not; the two are kept apart.

And the book itself is partly written, partly planned. Two series of public essays exist as prose; five more exist as locked structure — designed, not written. The manuscript is not done: the raw prose exists for the early arcs and is being converted, arc by arc. Four boundaries, one shape — the algebra is further along than the system, the deployment, the company, and the rest of the book around it — and saying so is the only way to let the reader trust the part that is done.

Why naming the edges is the point

It would have been easy to end on the strongest note — the proved suite, the clean replay, the two domains — and let the boundaries stay implicit. Gathering them instead, in the last chapter, is the same choice the whole book has been making in miniature. Every dated receipt, every "as of," every "operator-invoked," every "recall undefined" was a small refusal to claim more than was true. This chapter is those refusals collected into the closing argument.

A book that names its boundaries precisely is making a wager: that a reader can tell the difference between a system that hides its edges and one that draws them, and will trust the second more. The proved center of this book — the spaces, the operators, the axioms, the seven theorems — is exactly as believable as the boundaries around it are honest. If the "not yet" list were padded with things already done, the proved list would be suspect too. Because the "not yet" list is accurate, the proved list can be taken at face value. Honesty about the edges is not humility for its own sake; it is what makes the center load-bearing.

Close

So this is where Volume 1 ends — at its honest edge. It established an algebra for agents that is purpose-indexed, typed, and operational; it proved seven theorems about it and closed every debt; it bound the algebra to two real and unlike domains; and it stopped there, on purpose, naming what it did not do rather than blurring the line. The representation theorem is future work. The first production projection has not fired. The runtime and the economy are later volumes. The watcher is still learning, the binding is still at two, the company remains early, and the rest of the book is still being written. None of that is hidden, and none of it is hedged into vagueness; it is named, dated, and bounded — the same discipline, all the way down.

The opposite of an algebra is glue, and the opposite of a finished claim is an honest boundary. Volume 1 is the algebra — proved as far as it has been proved, bound as far as it has been bound — and the road past every edge named here is what the volumes after it are for. That road is mapped. It is not yet walked. And a book that knows the difference is the one worth starting from.