Chapter 7: Anatomy of a LogicalAssembly

The argument so far has been conducted entirely on other people’s artifacts — Plato’s beds, Shannon’s channels, the graveyard’s ontologies, the physicists’ self-instantiating knowledge. Part III builds one of ours. This chapter lays the artifact on the table: its six components, its four properties, and — since a definition is mostly fence — a deliberate account of what it is not. Readers who have come the long way around will recognize every part, because no part is new; several are older than the field that keeps reinventing them. What is proposed as new is the assembly: which parts, scoped by what discipline, held together by which loop, and consumed — everything turns on this — by something that acts.

I. The Six Components

A LogicalAssembly (Lasm) is an organization’s possibility space made explicit: the codebook that Chapter 2 found silently presupposed beneath every message, promoted from ambient culture to maintained artifact. It has six kinds of entry. Concepts are the distinctions the organization has resolved to make — what counts as a customer rather than a prospect, an outage rather than a degradation, a return rather than an exchange — the entities whose telling-apart the business depends on. Relations state how concepts compose: which party owns which account, which product satisfies which order, what contains, precedes, or supersedes what. Constraints are the invariants — what must hold for the domain to be in a legal state: every shipment has exactly one destination; no refund exceeds its originating payment; a suspended account places no orders. Events are the changes that count — the domain’s verbs, the transitions the organization has agreed to notice: order-placed, contract-signed, threshold-breached — and with them the domain acquires a clock. Policies are commitments about action: what should happen, by whom or by what, when an event occurs under a constraint — which approvals precede which disbursements, which incidents page a human being. Five components, and so far nothing a well-read architect has not seen before: concepts and relations are what the ontologies carried, constraints what the schemas enforce, events what the event-driven architectures catalog, policies what the rule engines ran. The graveyard is full of artifacts that had them, several at an expressiveness a Lasm will never need.

The sixth component is the one the graveyard lacked, and it is of a different kind. An evaluation is not a statement about the domain; it is a test of behavior against the other five — the organization’s criteria of success rendered executable: a harness that takes conduct (an agent’s proposed action, a projection’s output, a pipeline’s result) and returns pass or fail, with an address. The first five components describe; the sixth checks the description against what the described world and its actors actually do, and in doing so it converts the whole from documentation into infrastructure. By the thesis of Chapter 5, the decay rate of the first five is set by the sixth: entries that evaluations reach are load-bearing, and entries no evaluation can reach are drift-phase documentation whatever file they are stored in. That observation is also the scoping rule. A candidate entry earns inclusion by answering the corollary’s question — what will fail if this entry is wrong? — with the name of an evaluation; a candidate that cannot answer is excluded, deliberately, and the exclusion is recorded as a decision rather than deferred as a gap. Strip the evaluations away and the remaining five components compose an ontology with a new name. Chapter 5 already wrote that obituary.

II. The Four Properties

The preface asserted four properties on the strength of an analogy; the argument can now pay for them. A Lasm is a target, not a source. No committee sits down to author one the way committees authored the canonical models — the mode of production that gave the graveyard its knowledge-acquisition bottleneck. It is compiled: extracted from the schemas, the code, the policy documents, and the observed practice the organization already runs on, then reconciled where the sources disagree — and the sources disagreeing is not an obstacle to the method but its first payoff, since every reconciled disagreement is a place where two systems were quietly operating on different worlds. The direction of production also selects for truth: artifacts that already bear load are the least stale material an organization owns.

It is runtime-independent: no application, no vendor, no foundation model is named anywhere inside it. This is the database community’s data independence transposed up a layer — the logical schema designed, in 1975, precisely so that everything physical beneath it could be replaced without loss of meaning. The Lasm makes the same promise against a longer list of physics: applications above, models below, all replaceable while the meaning stands, and the replacement experiment is Chapter 8’s subject. It is enforced: evaluations gate consequential action the way validation gates execution — the assembly is consulted by things that act, and divergence from it fails early, visibly, and with an address. And it is a narrow waist: many sources compile in, many consumers project out, and the middle stays small because the volatility has been pushed to the edges where it belongs. The smallness is not modesty. An artifact scoped to what something will check stays small enough to keep true; smallness is the survival condition, and the waist is narrow for the same reason the load-bearing wall is not the whole floor plan.

III. What a Lasm Is Not

Fences, then, before the neighbors move in. A Lasm is not an ontology with better marketing. The difference is not expressiveness — on that axis it is deliberately the ontology’s inferior — but the sixth component and the scoping discipline: the ontology was scoped by coverage and consumed by nothing; the Lasm is scoped by enforcement and consumed at runtime. It is not documentation, a wiki, or a knowledge base; the corollary has already sorted those. It is not a database schema, though the schema is its closest living relative and among its richest sources — the schema governs one system’s storage and answers to that system’s writes, while the assembly governs meaning across systems and answers to action. It is not an industry standard: nothing about it is meant to travel between organizations, and two firms’ assemblies should disagree exactly where their businesses genuinely do — the disagreement is content, not noise. It is not a prompt, an agent configuration, or an application data model; those are projections — derived, plural, disposable, and the subject of Chapter 9. And it is not, in any interesting sense, an AI artifact. Nothing in the six components requires a neural network, and organizations occasionally built recognizable fractions of one, under other names, decades ago. What was missing was never the technology of representation. It was a consumer that made keeping the representation true worth anyone’s budget.

IV. The Missing Consumer

Chapter 2 located the load-bearing assumption of the entire twentieth-century arrangement: at the endpoint of every channel stood a reader, and between any received message and any consequential act, a human being interposed the codebook. Weaver’s Level C — meaning affecting conduct — sat unbuilt for seventy years because the reader made building it unnecessary. Chapter 4 found the same absence from the other side: the Semantic Web’s ontologies died of no runtime consumer, their wrongness costing nothing. The two observations were one observation, and agentic systems end it. An agent is software that consumes representations at runtime and acts — commits the funds, files the claim, changes the record, sends the message — with no reader interposed. It attended no apprenticeship and holds no tacit glossary; whatever meaning governs its action must be present, in consultable form, at the moment of action. Agents are the first widely deployed runtime consumers of meaning, and their arrival converts semantic error from a quietly wrong document — aging in a repository, patient, harmless until believed — into a wrong action with a cost, a timestamp, and an owner.

Stated as risk, this is the case for building the assembly; stated as mechanism, it is the reason the assembly can survive being built. A wrong action is exactly the failure signal Chapter 5 requires: observable, because it lands where attention already is — in the order flow, the ledger, the incident queue; attributable, because the action traces to the agent and the agent to the entry it consulted. The agent is the enforcement environment the graveyard never had. The same development that presents Shannon’s deferred note for payment supplies the collection mechanism: agents make the Lasm necessary, and agents make it durable, and these are not two facts but one fact read in two directions. The symmetry has a dark reading — an agent consults a stale assembly with the same efficiency, and Chapter 10 will give that reading its full weight — but the constructive reading comes first: for the first time since the field began burying its representations, there exists a consumer that fails, promptly and expensively, when the representation goes stale.

V. The Name as Thesis

The preface confessed that the name was chosen as an homage for Wasm and understood in hindsight; the anatomy now on the table lets the understanding be stated exactly. WebAssembly is a compact, portable, runtime-independent target: many languages compile into it, many hosts execute it, and a module runs only if it validates — enforcement at the narrow waist, millions of times a second, which is why the specification cannot rot. Map it term by term. The Lasm is the compilation target of the organization’s sources of meaning: schemas, code, policy, and practice compile in. Its hosts are the consumers: agents, applications, reports, and integrations project out. Its validation is the sixth component: evaluations gating action as the engine gates execution. Its portability is runtime-independence: the meaning survives the replacement of everything above it and everything below it. What WebAssembly is to computation, the LogicalAssembly proposes to be for domain meaning. The preface called that sentence a slogan and declined to assert it unearned; the anatomy makes it a checklist, and every box turns on the same hinge — whether the evaluations actually gate, at scale, every time, under the pressures that bend every gate. Gates, and the swap test that proves them, are the next chapter’s business.