02
The Primitive You Didn’t Have
For engineers who have shipped enough systems to recognize the recurring gap between doing work and proving work was done.
The Gap
Every serious system that touches regulated work ends up carrying two processes: the work itself, and the process by which the work is proven to have happened.
The work runs through the code. Evidence collection runs beside it — logs, audit tables, signed manifests, workflow attestations. The two are supposed to converge. They rarely do. Logs miss the semantic context that made the operation meaningful. Audit tables drift out of sync with the code that populates them. Manifests attest to artifacts and say nothing about the process that produced them. Compliance departments exist because the act of building software does not, by itself, leave behind the evidence an auditor needs.
The pattern reappears wherever a system has to produce provable outcomes: privacy compliance, supply chain integrity, AI oversight, sovereign federation. Two processes. Two costs. Two failure modes.
soma(som) starts from a different premise: what if the proof was in the work? What if the act of doing was, structurally, the same act as producing the evidence? The name records the split it eliminates — SOMA for the procedural body (the ring, the chain, what runs whether anyone watches), SOM for the interactive state of mind (what appears inside each cycle when perspectives meet). Two names, one system, always both.
Getting there requires giving up a habit. Most security engineering starts with requirements and designs structures to satisfy them. soma(som) inverts this. It starts with a single topological fact — structural incompleteness — and observes what falls out. The interesting properties (tamper evidence, third-party attestation, perspectival privacy, semantic identity, state commitment) are not designed. They emerge.
The Primitive
The primitive is called the Quad.
Q = (R, P, T)
R → Root the standpoint — position, the current key
P → Pointer the focus — the binding key that opens the next layer
T → Tree the surroundings — the reachable references from here
Three attributes are held inside the Quad. A fourth constituent — the binding, written β — is held outside. β is the predecessor’s Pointer value, the key by which the predecessor addresses this Quad. β is not held here. It is also not held by the successor. The name records the asymmetry: three inside, one outside.
The Quad is the universal structural element. Every processing unit is a Quad. Every layer inside a unit is a Quad. Every crossing between them is a Quad. One primitive, one shape, everywhere.
The triadic form — Root / Pointer / Tree — is not decorative. It is consistent with Peirce’s Reduction Thesis on state: higher-arity relations decompose into triadic combinations, and the fourth constituent (β) is held by the predecessor, not inside Qi itself. This is the topological fact that everything else follows from.
The Ring
Six processing units form a directed cycle:
FU → MU → CU → OU → SU → HU → FU
Each unit answers one irreducible interrogative, and each unit is a Quad whose Root is a position on the cycle.
- FU — Foundation Unit — WAI, Who Am I? — self-location and environment
- MU — Meaning Unit — WIU, What Is Up? — context interpretation
- CU — Conscience Unit — WCN, What Comes Next? — policy evaluation
- OU — Operator Unit — WAY, Who Are You? — identity, authentication
- SU — Surface Unit — WAW, Where Are We? — presentation, shared view
- HU — Hub Unit — WDW, When Do What? — action, scheduling, history
Completing the sixth unit opens the door forward. The ring’s closure is HU→FU; the cycle-close is what seeds the next cycle. One traversal is one complete state of mind.
Three Invariants
Three invariants make the ring a ring:
- Ring closure. The six-unit traversal must complete and return to FU. σ6(u) = u. Within a single cycle, no shortcuts, no parallel paths. If the return link breaks, the ring degenerates into a pipeline and constitutive production ceases.
- No bypass. Every state mutation traverses every unit through the boundaries between them. The ring is the sole execution path — no back door into internal state that skips a unit.
- Awareness closure. The commitment produced at each crossing is folded into the awareness fingerprint. A cycle that does not close its awareness cannot be verified as a cycle at all.
The web layer talks to this ring through two structural doors:
- IN: commands are injected into FU.Data namespaces.
- OUT: results are read from OU (persistence) and SU (presentation).
No direct writes from the web layer. No ring bypass. This is what “perspectival centralism” means at the code level — the ring mediates every state mutation.
What Falls Out Of Structural Incompleteness
Embed a Quad in the directed ring and a property emerges that you cannot engineer away.
The predecessor holds a reference to the current Quad — the Pointer Pi-1 that identifies Qi from outside. But Qi does not hold Pi-1. It cannot. The ring’s directed topology means Qi can see:
- its own state: (Ri, Pi, Ti) — inside
- the next Quad it references: Qi+1 via Pi — forward
It cannot see:
- how it is referenced: Pi-1 — behind
No restructuring of the ring can give a Quad access to its own external key while preserving the directed topology. This is the body problem.
It is not access control (information exists, access denied). It is not information hiding (information exists, concealed). The information does not exist at Qi’s position. Compromising Qi yields (Ri, Pi, Ti) and nothing else. A vantage point external to Qi is required for any statement about how Qi is referenced to be uttered.
From this single topological fact, four system-level properties fall out:
- Security. Compromising Qi yields Qi’s own attributes but not Pi-1. There is no single-point full-identity compromise, because no single point holds the full identity.
- Integrity. Verification is always other-certified. Each unit verifies its predecessor. No self-certification.
- Fingerprinting. The awareness fingerprint is a collective property of the full ring, requiring complete traversal.
- Epistemology. Knowledge is perspectival by topology. Opacity is geometry, not policy.
These are not features layered on. They are what the ring is.
The Witnesses
Between every layer transition and between every unit, a boundary stands. The boundary belongs to the threshold, not to either side. When a crossing happens, the boundary signs a record of what crossed. The record includes a reference to the previous record’s hash. The signatures chain.
The cryptographic surface is deliberately small. One hash algorithm and one signature algorithm are enough — the fewer the primitives, the fewer the failure modes. Any subsequent change to a record breaks every hash after it, and forward verification detects the break in a single pass.
Three properties of the witness structure matter for how the ring produces evidence:
Third-party attestation. The boundary signs, not the producing unit. The signature is proof that the boundary observed the crossing. The producing unit cannot repudiate — it was not the signer. No self-certification anywhere in the chain.
Perspectival privacy. At each crossing, the boundary strips the predecessor’s Pointer before delivering the record to the successor. The record is signed after the strip. The signature is cryptographic proof that the receiving unit did not observe the predecessor’s Pointer. Privacy is not “you may not see” — it is “you did not see, and here is the signature that proves it.”
Semantic identity. The chain’s hash includes a semantic context that describes what kind of cycle happened, under whose authority, for what purpose. The chain does not just prove a cycle occurred; it proves what it was for. Retroactive reclassification breaks the chain.
Together, these mean the chain of witnesses does not merely record events. It records commitments — self-verifying, other-attested, semantically bound.
Genesis
The ring requires closed-loop verification. Closed-loop verification requires an existing ring. The body problem compounds this: no unit can self-certify, and at genesis there is no predecessor chain.
The resolution is to acknowledge that circularity requires a linear origin. At time zero the ring is open. An initial state is deposited into FU. The first cycle traverses the six units. HU→FU feedback completes. The ring closes. Every cycle thereafter chains to the one before, with verification available in both directions:
- Forward. Recompute the hash of the current state combined with the previous state’s hash; compare against the recorded value.
- Backward. Trace from any snapshot all the way back to genesis.
The genesis hash is the trust anchor. The temporal ledger is a chain from the present moment to the origin. No external timestamping authority is required.
What The Ring Knows — And What It Does Not
The Conscience Unit — CU — is the ring’s knowing field. It evaluates policy against the data in the Tree it received: anticipation, commitment, prediction. CU emits proposals — not commands. A sequence of gates resolves to a scalar autonomy level, and the effective autonomy is the minimum across all gates. The proposal carries forward to OU.
The Operator Unit — OU — is where the proposal becomes a decision. OU attaches the identity boundary: which actor, under which authority, at which moment. The witness at OU signs both the decision and the authority level it was made under. OU is the designated trust anchor of each cycle; CU is where the reasoning was done.
CU has zero external coupling. Tree in, Quad out. Everything CU needs to reason with has been deposited in FU.Data by the caller and threaded through the ring’s earlier stages.
This is how the ring governs automated decisions. CU reasons. OU decides. The witness at OU stamps both the decision and the authority under which it was made. Provable human-in-the-loop is not a policy document. It is a cryptographic fact.
The ring evaluates, witnesses, and chains. It does not learn. It does not adapt. It does not decide what is right. Those things belong where they should belong — in the interactive encounter, with the humans and other systems participating in it.
The Extension Model
The ring runs as a closed engine. Extensions relate to it in one of five structural positions:
| Relationship | When | What |
|---|---|---|
| BEFORE | Pre-unit processing | Gate, validate, enrich before a unit runs |
| AFTER | Post-unit processing | Observe, record, react after a unit runs |
| AROUND | Wrapping a full cycle | Cross-cutting concerns — tracing, security policy |
| THROUGH | Intra-processor | Delegation inside unit logic |
| WITHIN | Internal to a unit | Unit-private helpers |
THROUGH is not engine-registered — it is intra-processor delegation. The ring engine itself has no dependencies on unit implementations or the extensions that stand in relation to it. It is a pure ring engine.
Each service that stands in relation to the ring owns its own store — no shared database, no cloud dependency. The isolation pattern is called a solitaire: self-contained, own store, own trait, own deployment boundary. The composition of solitaires is what the system exposes to its callers — the ring plus the services that stand around it.
Test coverage runs at multiple layers: unit tests inside each solitaire, integration tests across ring composition, load profiles that exercise cycle throughput under pressure, end-to-end runs that walk realistic scenarios from the outside. Each layer catches a different class of drift.
Fractal Composition
If the Quad-ring-witness pattern holds at one scale, does it hold when composed? When an inner ring completes a full cycle and its output crosses into an outer ring, does the body problem still apply? Do the cryptographic properties compose?
The structural argument is straightforward: if each inner ring maintains its own directed topology and its own witness chain, and the outer ring treats inner-ring outputs as Tree data injected through FU.Data, then scoping, attestation, and perspectival privacy hold at the outer boundary by the same topological argument that holds at the inner one.
A full proof of the composition is still open, and this is honest. What is established: the shape looks the same at every scale that has been tested, and the invariants that make the ring work at one scale are exactly the invariants required at the next.
If composition holds, then multi-organization federation reduces to ring-to-ring composition: each organization maintains its own chain, federation happens at the boundary, the witness at the boundary stamps what crosses, neither side sees the other’s internal cycles. Sovereignty preserved. Provenance shared. Trust produced, not assumed.
What Makes It Novel
Standard security engineering starts with requirements and designs structures to satisfy them. soma(som) inverts this. The Quad is epistemologically incomplete by construction; the ring enforces directed traversal by construction; the cryptographic properties (tamper evidence, third-party attestation, perspectival privacy, semantic identity, state commitment) emerge from these structural facts and cannot be removed without breaking the topology that produces them.
The body problem is not information hiding, not least privilege, not access control. It is topological incompleteness: the information does not exist at the observer’s position. This is a structural claim, not a security policy.
Whether the epistemological derivation produces genuinely different system properties from the requirements-first approach is an open question — the structural effects converge with information hiding and least privilege in what they achieve at runtime. The cause differs: topology rather than policy. The consequence differs when the requirements shift: policy has to be redesigned, topology continues to hold.
Standard architectures earn trust by satisfying requirements.
soma(som) earns trust by refusing the vantage from which trust could be forged.