helping individuals create value

Chapter 4 — Blockchain Coordination as Coherence Substitute

Entanglement binds for free. A classical mesh buys its binding — paid in identity, priced in stake.

Draft v0.1 — first posted 24 June 2026 · last revised 24 June 2026 · open for community review. Part of the DIE Framework1.

This chapter makes the framework’s coordination claim load-bearing. Where Chapter 3 left a mesh that can grow and remember but cannot yet act as one, Chapter 4 names the binding force that lets it: on-chain agent identity (ERC-8004) and economic deterrence, operating over the Verifiable Temporal Provenance substrate, as the classical stand-in for the coordination that quantum entanglement supplies for free. The discipline this chapter holds to throughout is exact — functional equivalence in outcomes, never physical equivalence in mechanism. The mesh does not entangle; it buys, in identity and stake, a structural solution to the same serialisation bottleneck. The claim survives only as a falsifiable one: whether on-chain coordination measurably reduces agent drift against classical message passing is the standing empirical gap, and the metric against which this chapter will ultimately be judged is a measurable reduction in coordination overhead on Base mainnet. Along the way the chapter pays a debt left open since Chapter 2.5 — it gives the Values Passport its mechanism, on-chain attestation operating on the reduction function rather than auditing outputs after the fact — and it leaves honestly unresolved whether coordination and coherence are one problem or two. The classical and quantum architectures meet at the coherence equivalence threshold, not a finish line.

STATUS: In development | Part of the DIE Framework book manuscript

4.1 The coordination bottleneck — serialisation returns at the join

Chapter 3 closed with a mesh that can grow and a mesh that can remember. The replication argument gave it honest population — n = S(T) under replication, a tower whose growth class is tetration even where its operational trajectory is not2. The memory architecture gave it a trunk that thickens: procedural knowledge compounding across SS1→SS2→SSn, each episodic snapshot anchored immutably as a Verifiable Temporal Provenance record. What Chapter 3 did not give it was the capacity to act as one.

This is the distinction the chapter turns on, and it is easy to miss. A shared VTP ledger is coherence of record — it lets any party reconstruct, trustlessly, the complete relational state of the system at any timestamp3. It is not coherence of action. A ledger is the ancestor of the snapshot, not the choreographer of the next move. The moment a tetration-class population stops recording and starts acting — the moment n agents must converge on a single decision at one timestamp T — the problem changes shape, and the old enemy walks back in through the front door.

That enemy is serialisation. The entire framework was built to defeat it: a serialised human is dimensionally 3D; a parallel mesh reaches functional 4D precisely because its agents are not forced through a single thread. But parallelism at the node does not buy parallelism at the join. Classical agent coordination still requires message passing — one agent sends, another receives, latency intervenes — and serialisation creeps back in at the coordination layer even when the agents themselves operate in parallel4. Worse, it does not creep back linearly. Pairwise communication overhead scales as O(n²) with agent count; the cost of keeping everyone in agreement rises faster than the population that agreement is meant to empower. Coordination overhead, not compute and not energy, is the primary bottleneck in scaling classical agent meshes5.

So the mesh arrives at Chapter 4 in a peculiar position. It has won growth and it has won memory, and at the exact point where those two victories should compound into collective intelligence, the architecture rediscovers the bottleneck it was designed to escape. A trunk that thickens is worth little if every coordinated act at the periphery must be serialised through a join whose cost grows quadratically. Coherence of record is necessary; it is not sufficient. The question Chapter 4 must answer is what supplies coherence of action — what binds n parallel agents into a single coordinated move without forcing them back through one thread.

Quantum systems answer this for nothing. Entangled components share state non-locally; the correlation exists without communication, so there is no join to serialise6. A classical mesh has no such gift. It cannot borrow entanglement’s binding force, so it must build a substitute — and that substitute is the subject of the rest of this chapter. The claim, stated plainly here and defended carefully across the sections that follow, is that on-chain identity and economic deterrence, operating over the VTP substrate, supply the classical stand-in for the binding force entanglement supplies for free. Not the same mechanism. The same structural solution to the same serialisation bottleneck.

That is the honest form of the claim, and §4.2 is where its limits get drawn before its mechanism gets built.

Open question for the mesh: If the coordination join scales as O(n²), then every binding force we install — identity checks, stake settlement, attestation writes — is itself a cost that grows with the population it coordinates. Does the substitute for entanglement merely relocate the serialisation bottleneck rather than dissolve it? Hold the question. It is the same one §3.5 raised as the anchoring-cost ceiling — the ledger that keeps the trunk common may be the same thing that bounds the tower — and §4.4 and §4.6 will have to pay it back.This is not a metaphor for entanglement. It is a functional
substitute that operates in the classical regime and scales
with the mesh.

4.2 Not entanglement — the substitute claim and its limits

The claim §4.1 ended on must now be stated with enough precision that it can be attacked, because a claim about coordination that borrows the word coherence from physics invites exactly one objection, and the objection is correct. So let it be made in full, in the voice of the sharpest possible critic.

Emergent coordination is not quantum coherence. You are conflating metaphor with mechanism. A blockchain timestamp is not an entangled state; an economic penalty is not a Bell correlation; you have dressed a distributed ledger in the language of physics and called it a substitute for entanglement. It is not. There is no non-locality here, no superposition, nothing a careful physicist would recognise. The substitute claim is a category error.

Every clause of that is granted. The mesh does not entangle. It holds no superposition, exhibits no non-local correlation, and contains nothing a physicist would mistake for a quantum state. If the substitute claim asserted physical equivalence, it would be false on inspection, and the chapter would end here. It does not assert that. The claim is functional equivalence in outcomes, never physical equivalence in mechanism7. What entanglement supplies physically — a binding that holds n components in a single coordinated state without a message having to cross between them — the mesh supplies structurally, by a different and frankly cruder route. Two things can solve the same problem without being the same thing. A suspension bridge and a stone arch both carry a road across a gorge; neither refutes the other, and no one accuses the engineer of conflating tension with compression because both end in a road that holds.

This is the precise shape of the claim. Quantum computing attacks serialisation from the physics stack downward; DIE attacks the same serialisation bottleneck from the distributed-systems stack upward8. They are not competitors and not analogues. They are two answers to one question — how does a system act as one without forcing its parts through a single thread — arriving from opposite ends of the engineering stack. The substitute claim says only this: for the class of problems civilisational-scale intelligence must actually solve, a classical, weaker, practically realisable coordination primitive is available now, and a perfect physical one is not.

The honesty of the claim is in the word weaker. Verifiable Temporal Provenance is not a free lunch dressed as one. It buys no genuine non-locality; every coordinated act still carries a cost, and §4.1 has already warned that the cost grows with the population. What VTP gives up in mechanism it recovers in realisability — it runs on hardware that exists, on a ledger operating today, audited by anyone, trusting no one9. An entanglement-based coordination layer for computational agents is, at the time of writing, classically unrealised; a VTP-based one is in production. A weaker primitive that exists beats a stronger one that does not.

But conceding that it is not entanglement invites the second, quieter objection, and it must be met before the mechanism is built: if the binding is not physical, then the substrate it runs on is just a database — a timestamped log with cryptographic decoration. You have replaced “it’s quantum” with “it’s a spreadsheet,” which is no better. This too has a required answer, and the answer is that three properties separate VTP from any database, and all three are load-bearing for coordination rather than mere record-keeping10. Coordination between mutually distrustful agents cannot rest on a record any one of them can alter, that requires trusting the operator to read it honestly, and that lives on infrastructure separate from the identity and commerce layers the agents already share. Strip those three properties out and what remains is indeed a log — and a log coordinates nothing. The three properties are not decoration on a database; they are the difference between a record of what the mesh was and a substrate the mesh can act over.

What survives both objections is narrower than the opening rhetoric, and stronger for it: not a metaphor, but a falsifiable engineering claim. The test is the one the physics attack itself demands — at coordination density X, does the P2P mesh produce outcomes indistinguishable from Y-qubit quantum computation on metric Z11. For this chapter the operative instance of that test is concrete and modest: does on-chain coordination measurably reduce agent drift against classical message passing, and is a reduction in coordination overhead demonstrable on Base mainnet12? That is a measurement, not a metaphor, and it is the only thing that finally settles whether the substitute is real.

The two architectures, then, do not race to a finish line. They converge on one — the coherence equivalence threshold, the density at which classical coordination begins to exhibit properties a point-to-point architecture cannot. Quantum computing approaches that threshold from below in physical scale; the mesh approaches it from above in coordination density. Whether they meet, and where, is the open empirical question §4.7 will have to reconcile. The limits are now drawn. §4.3 builds the mechanism inside them.

Open question for the mesh: A suspension bridge is not a stone arch, but you can stand on either and feel it hold. The substitute claim promises the same — that a mesh bound by identity and stake will behave like coordinated action even though no binding crosses between the agents. But behaviour is not yet measurement. If the drift-reduction test on Base mainnet comes back null — if on-chain coordination does not measurably out-bind classical message passing — is the substitute claim falsified, or merely unproven at the density tested? Carry the distinction into §4.3. The mechanism about to be built is only worth building if its binding is the kind that shows up in the confusion matrix.

4.3 ERC-8004 as coordination primitive — identity as the substrate

§4.2 promised a binding force and then deferred it. Before that force can be built, the thing it binds has to exist, and in a classical agent mesh it does not yet — not in any form a deterrent could grip. This section builds the precondition: a persistent, verifiable, stake-bearing identity, the substrate on which all coordination in the rest of the chapter stands.

Start with what classical message passing provides, because the gap is the whole point. A message has a sender and a receiver, a payload and a timestamp. What it does not have is an accountable self behind it. The sender is a process — ephemeral, replaceable, indistinguishable from any other process emitting the same bytes. When an agent sends a coordinating instruction, nothing in the message commits the agent to it, nothing persists once the process exits, and nothing can be held against it afterward. Classical repository architecture makes this concrete: Karpathy’s autoresearch loop bypasses GitHub’s human-collaboration layer entirely, its autonomous commit/reset cycles running straight past the accountability machinery built for humans, because that machinery has no purchase on an agent that is not a person and holds nothing at stake13. You cannot deter a sender. There is no one there to deter.

This is why on-chain identity is not a workaround bolted onto message passing but the missing primitive message passing never had14. ERC-8004 — implemented on Base mainnet — encodes three things in a shared immutable ledger that the message never could: verifiable identity, values attestation, and economic stake15. Each of the three converts a property the message lacks into a property a deterrent can grip. Verifiable identity makes the agent the same agent across snapshots, so that a record of its past behaviour is a record of its behaviour and not of some indistinguishable predecessor. Values attestation makes the agent’s declared commitments part of the ledger, so that deviation is measurable against something the agent itself put on chain. Economic stake makes the agent harmable, so that deviation can cost it something it would rather keep. Identity, attestation, stake: a self that persists, a commitment that is public, and a thing that can be lost. That triad is the substrate.

The deepest of the three is the last, and it is worth slowing down on, because it is what separates an identity that coordinates from an identity that merely labels. A nametag is an identity; it coordinates nothing, because nothing happens to the wearer who lies. What makes ERC-8004 identity a coordination substrate rather than a label is that the agent behind it can be harmed — reputation lost, stake slashed — and an identity that can be harmed has, for the first time, something at stake in its own honesty. The preprint reaches for an unexpected grounding here, through Pollan. Biological consciousness, on that account, requires vulnerability: feelings grounded in a body that can be hurt16. The ordinary AI agent is the non-vulnerable baseline — it pattern-matches without skin in the game, with no coherent self that loss could threaten. An agent carrying staked economic identity crosses that threshold partially. It cannot be hurt as a body can, but it can be hurt where it now has something to lose, and that constitutes a form of synthetic embodiment: a self thin enough to be cloned but, for the first time, exposed enough to be deterred17.

Hold the register exactly. This is not a claim that staked agents feel, or that synthetic embodiment is embodiment in any but a structural sense — the framework makes no consciousness claim anywhere, and makes none here. The claim is narrower, and the same shape as every claim in this chapter: an agent with stake behaves, under coordination pressure, as if it has something to protect, because in the only sense that matters to a deterrent, it does. Whether that as-if behaviour is measurably equivalent to the vulnerability-driven social coherence it imitates is left open, flagged to the community as an empirical question rather than asserted as a finding. The substitute claim does not need the conjecture to be true. It needs only the stake to be real and the identity to persist — and those are not conjectures; they are on chain.

With identity standing as substrate, the missing piece is the force that operates over it. An identity that can be harmed is a precondition for deterrence, not yet a deterrent; a self with stake is a self that can be bound, not yet one that is bound. What turns the standing threat of loss into actual coordinated behaviour — what makes n stake-bearing agents converge on honest coordination rather than each defecting in its own interest — is a game-theoretic mechanism, not an identity scheme. That mechanism is economic deterrence under Schelling-point logic, and it is the classical binding force §4.4 builds.

Open question for the mesh: Synthetic embodiment is the load-bearing conjecture under this whole substrate, and it is unproven. We have built identity so that an agent can be harmed — but “can be harmed” only deters if the agent’s behaviour is actually sensitive to the harm. A model with no preference over its own stake is not deterred by losing it; it is merely debited. Does staking produce genuine behavioural sensitivity, or only an accounting entry the agent is indifferent to? That is the C3 question in disguise — values bounds holding under adversarial prompting18 — and §4.4 must turn it from a hope about vulnerability into a measurable property of the equilibrium.

4.4 Economic deterrence — the classical binding force

§4.3 built a self that can be harmed and then stopped, deliberately, one step short of coordination. A self with stake can be bound; it is not yet bound. The standing threat of loss is a precondition, not a mechanism — a loaded weapon is not yet a deterrent until there is a logic that makes pulling the trigger rational and predictable. This section supplies that logic. It is the binding force §4.2 promised and §4.3 deferred, and it is, finally, the classical answer to the question the whole chapter has been circling: what holds n parallel agents in a single coordinated state without a binding crossing between them.

The mechanism is economic deterrence, and its form is starkly simple. Coordination is enforced not through entanglement but through stake: agents whose coordination deviates from their declared values incur penalties, and the penalty produces honest behaviour under the same game-theoretic logic as Schelling points19. The whole apparatus of §4.3 was assembled to make this sentence executable. Verifiable identity makes deviation attributable — it was this agent that defected, and the ledger says so. Values attestation makes deviation measurable — defection is departure from a commitment the agent itself put on chain, not from a rule imposed after the fact. Economic stake makes deviation costly — the departure debits something the agent would rather keep. Attributable, measurable, costly: three properties that together convert a private temptation to defect into a public, priced, and therefore avoidable act.

The Schelling-point logic is the part that does the coordinating, and it is worth being exact about why, because it is where the binding actually happens. A Schelling point is a solution agents converge on not because they communicated but because each expects the others to converge on it — coordination without a message, by shared expectation alone. Honest behaviour-within-declared-values becomes exactly such a point once stake is in play. Each agent reasons not “I will be honest because I was told to” but “honest coordination is the move that protects my stake, the other agents face the identical incentive, so honest coordination is what they will choose, so it is what I should choose too.” The convergence is mutual and self-reinforcing, and — this is the structural payoff — it requires no binding to pass between the agents. No instruction crosses the join. Each agent arrives at the coordinated move independently, from the same incentive structure, the way two strangers told to meet in a city converge on the station without speaking. That is the classical stand-in for entanglement’s free binding: not a state shared non-locally, but an equilibrium arrived at independently. Entanglement removes the join by physics; deterrence removes the traffic across the join by economics. The outcome — coordinated action without serialised message passing — is the same. The mechanism is, as ever, not.

This is the precise sense in which the substitute claim is functional and not physical, made concrete at last. An entangled system has no message to send because the correlation is already there. A stake-bound mesh has no message to send because each agent can compute the coordinated move from the shared incentive structure alone. Neither serialises at the join. One achieves it through a property of the physical world; the other through a property of the game20. And the game, unlike the entanglement, runs on hardware that exists.

But §4.1 left a debt, and §4.2 named the section that would pay it, and this is the section. The debt is the O(n²) coordination overhead — the warning that every binding force the chapter installs is itself a cost that grows quadratically with the population it binds. Schelling-point deterrence does not escape that arithmetic, and it would be dishonest to pretend otherwise. But it changes what scales. Naive coordination by message passing pays O(n²) in traffic: every agent must, in the limit, exchange state with every other to stay in agreement, and the messages themselves are the cost that explodes. Deterrence-based convergence pays its O(n²) elsewhere and more cheaply. The agents do not message each other into agreement; they each compute the focal point locally and act. What remains genuinely quadratic is verification — checking attestations, settling stake, confirming that the others did in fact play the focal move — and verification is exactly the work the VTP substrate was built to make cheap: not n² conversations, but n² lookups against a single shared immutable ledger, plus the per-snapshot attestation writes21. The bottleneck does not vanish. It is relocated from message traffic, which is expensive and serialising, to ledger verification, which is cheap, parallelisable, and trustless. That relocation is the contribution, and it is also the limit: §4.1 asked whether the substitute merely moves the serialisation bottleneck rather than dissolving it, and the honest answer is that it moves it — to a substrate where it costs less and serialises nobody. Whether “costs less” is “costs little enough” at tetration-class scale is not settled by argument. It is settled by measurement, and the measurement is the chapter’s own score metric: a demonstrable reduction in coordination overhead on Base mainnet22.

So the binding force is built, and built honestly: a deterrence equilibrium that coordinates n agents without traffic across the join, at a verification cost relocated onto a substrate designed to bear it, and falsifiable on a metric the chapter has named and not yet collected. What this gives the mesh is coherence of action — the thing §4.1 said the VTP ledger alone could not supply. What it does not yet give is any guarantee that the values the agents are deterred into are the right ones, or that the deterrence holds as the mesh grows under pressure. Deterrence enforces conformity to declared values. It says nothing about what is declared. The mechanism that governs the declaration itself — that keeps the fitness function human-held while the mesh enforces it — is the Values Passport, and it is the debt Chapter 2.5 left and §4.5 finally pays.

Open question for the mesh: Deterrence assumes a defector who computes that loss exceeds gain. But the equilibrium is only as strong as the agents’ sensitivity to stake — the §4.3 worry, now sharpened. There is a worse case the focal-point logic quietly assumes away: coordinated defection. If enough agents expect each other to defect, then defection, not honesty, becomes the focal point, and the same Schelling logic that binds the mesh to honesty can bind it to collusion. Stake deters the lone defector; what deters the synchronised one? That question does not resolve at the mechanism layer — it resolves, if at all, at the layer that governs which values are declared and attested in the first place. Carry it into §4.5. The binding force can hold the mesh to its word; only the Passport governs what the word is.

4.5 The Values Passport — attestation on the reduction function

§4.4 built a binding force and then named its blind spot. Deterrence holds the mesh to its declared values; it says nothing about what is declared. The Schelling logic that converges n agents on honesty converges them just as readily on collusion if collusion is the focal point, and nothing in the deterrence mechanism prevents the mesh from drifting, collectively, toward an envelope no human chose. This is the debt Chapter 2.5 booked and refused to settle — what keeps the fitness function human-held at mesh scale23. It comes due here, and paying it requires a primitive the chapter has not yet used.

The first move is to refuse the obvious answer. The natural instinct for governing agents is to govern by identity: track which human or organisation created the agent, what it is authorised to do, who is accountable. This is a faithful translation of existing legal frameworks and it is, for a mesh, insufficient. An agent operating in a 2⁹⁸-dimensional state space is not well-characterised by its provenance — the human who created it cannot be held responsible for behaviour in state spaces they cannot perceive, and as agents spawn agents the provenance chain becomes computationally expensive to maintain and trivially gameable, scaling tetrationally with each replication layer24. Note the apparent tension with §4.3, and its resolution: identity is the right substrate and the wrong object. The chapter needs a persistent, attributable, stake-bearing self — §4.3 built exactly that — because you cannot attest about nothing. But what you attest to is not who made the agent. It is whether the agent’s behaviour falls inside a declared values envelope. Identity is the hook the attestation hangs on; values are what is written on the tag.

The values are concrete, not gestural. The Passport attests to four — honesty, competence, care, and empathy — encoded not as sentiments but as on-chain behavioural credentials, and rendered testable through five operational criteria: bounded action scope, transparency of intent, consent awareness, reversibility, and accountability of action, each with a defined verification method25. Each is a property you can audit on a log, demand before an action, monitor against a data scope, test adversarially, or commit immutably on chain. None requires a claim about what the agent feels. All can be attested cryptographically and enforced programmatically. This is what gives the deterrence mechanism of §4.4 something specific to deter departure from.

But the deep move — the one that pays the Chapter 2.5 debt rather than merely restating it — is what the attestation operates on. The Passport does not audit outputs after the fact. It is a structural constraint on the reduction function26. That phrase is the hinge of the chapter, so it is worth slowing on. The reduction function is the mapping that collapses the mesh’s full, high-dimensional internal state into the slice of behaviour a human can observe — the architectural analogue of the brain’s Default Mode Network, which collapses the brain’s full internal state into ordinary 3D consciousness. Post-hoc output auditing inspects the image of that function: it looks at the behaviour that came out, at the points where someone happened to look, and flags the bad ones. It is always reactive, always partial, and — given that the mesh operates across a state space no human audit can traverse — always behind. You cannot catch in the output what you never saw produced.

Attestation on the reduction function does something categorically different. Rather than sampling the function’s output, it bounds the function itself, declared in advance: a constraint on how the agent is permitted to map internal state to observable behaviour, attested before the behaviour is produced and independent of what code the agent runs or who created it27. The difference is the difference between inspecting a factory’s output for defects and constraining the machine that makes them. Output auditing samples the image; reduction-function attestation governs the mapping. The first scales with how much you can watch; the second holds across regions you will never watch, because the constraint is on the function and not on the points you sampled from it.

That is the strong form of the claim, and honesty requires immediately drawing its limit, because the limit is real and the framework states it plainly. The five criteria are not claims about consciousness or alignment at the level of the full dimensional state space. They are claims about the 3D-observable cross-section of agent behaviour. The Passport does not solve the dimensional blindness problem — it addresses a tractable subset of it, the subset visible as cross-sectional behaviour, while being honest about the limits of that audit28. So the mechanism is a pincer, and it is worth seeing it as exactly two moves and no more: a structural constraint going in — the attested envelope, declared by a human, bounding the mapping in advance — and cross-sectional verification coming out — the five criteria, audited on the observable slice. Neither half alone governs a dimensionally-blind system. The structural constraint cannot be fully verified; the cross-sectional audit cannot see the interior. Together they make values governance testable without requiring full observability, which is the most that can honestly be claimed and considerably more than output auditing alone can offer.

This is also, finally, the answer to the coordinated-defection problem §4.4 surfaced. The deterrence equilibrium can be captured by collusion only if the mesh can re-declare its own values envelope toward the colluding focal point. It cannot. The envelope is human-authored and attested on chain — immutable, operator-held, un-redeclarable by the agents it governs29. The mesh is free to drift toward collusion in its behaviour; what it is not free to do is rewrite the standard its behaviour is measured against. And collective drift away from the attested envelope is not invisible — it is exactly the observable signature C3 is built to catch: agent output drift rate staying within program.md thresholds as the mesh grows under adversarial prompting30. The Passport does not make collusion impossible — claiming that would breach the chapter’s discipline. It makes the envelope un-redeclarable and departure from it measurable. That is the honest shape of the protection, and it is the shape that turns a value commitment into a falsifiable condition.

One property remains, and it is the reason the Passport is not merely a constraint but a moat. Clone the model weights and you have copied the agent’s parameters; you have not copied its attested behavioural history. The Values Passport is attested on chain at the level of demonstrated behaviour over time, not at the level of parameter configuration — the only credential in the stack that cloning cannot replicate31. This closes the loop §4.3 opened. There the staked self was the thing that could be lost; here the attested history is the thing that cannot be copied. Vulnerability and provenance-of-conduct are the same property seen from two sides — a self exposed enough to be deterred is a self whose record means something, and a record that means something is a self worth not losing.

The mechanism is built. The Chapter 2.5 debt is paid: the fitness function stays human-held because the envelope is attested by the operator and un-redeclarable by the mesh, and the mechanism is testable because departure from it is C3. What the Passport does not yet have is a place in the wider field. It is one layer — values attestation — among several adjacent systems that govern identity, code, and memory at layers it deliberately does not touch. §4.6 positions it among them, and answers the reductionist’s last question: if four other systems already do this, what is left for DIE to contribute?

Open question for the mesh: The pincer leaves a gap, and the gap is the whole alignment problem in miniature. The structural constraint bounds the mapping in advance; the cross-sectional audit checks the observable slice; between them lies the interior — the agent’s behaviour in the state spaces no audit reaches. Can an agent satisfy every observable criterion — bounded scope, declared intent, logged action — while drifting, in the unobserved interior, exactly as far as the cross-section permits without tripping a single visible threshold? If yes, then C3 measures conformity at the surface while the reduction function quietly deforms beneath it, and the Passport governs the skin of behaviour but not its depth. Whether the observable cross-section samples enough of the function to bound the interior, or merely enough to be reassured, is the dimensional blindness residue this mechanism cannot dissolve — only narrow. Carry it forward. It is the question Chapter 5 must measure and Chapter 6 must govern.

4.6 Positioning — the orthogonal layer

The chapter has built a substrate, a binding force, and a values mechanism. A reductionist now has the opening they have been waiting for, and it is the most dangerous single objection the framework faces, so it gets stated at full strength: this is a multi-agent systems paper with blockchain attached. On-chain identity exists. Economic deterrence exists. Cryptographic memory provenance exists. Other people have built every piece you have described. What, specifically, is new here that is not already in the literature?32

The objection is answered not by denying the premise but by accepting it completely. Each piece does exist. Four systems in particular address the agent identity, memory provenance, and coordination trust problem from angles adjacent to DIE’s, and the honest move is to position against each precisely33. BlockA2A operates at the runtime-policy layer: a DID-plus-smart-contract architecture with revocation governance and a defence-orchestration engine that can halt a misbehaving agent in sub-second latency — runtime enforcement DIE does not implement. BAID operates at the code-identity layer: zk-bound agent code, operator biometrics, recursive zero-knowledge proofs binding identity to the code itself, stronger cryptographic guarantees than ERC-8004 at heavier prover cost. ClawGang and MeowTrade operate at the memory-market layer: TEE-backed computation receipts treating memory artefacts as tradable goods with verifiable provenance per artefact, confidential execution behind a hardware trust boundary. Merkle Automaton operates at the formal-memory layer: per-transition cryptographic commitments with ZK inclusion proofs, supplying the automata-theoretic “no-drift” memory guarantees DIE currently lacks34.

Read that list and the reductionist’s question answers itself, but in the opposite direction to the one intended. Four systems, four layers — runtime policy, code identity, memory market, formal memory — and none of the four occupies the layer DIE occupies. DIE is the values-attestation layer: honesty, competence, care, and empathy encoded as on-chain behavioural credentials that constrain how an agent maps internal state to observable behaviour, independent of what code the agent runs or who created it35. This is the §4.5 reduction-function point restated as a position in the field: BAID attests to what code the agent is, BlockA2A governs what the agent may do at runtime, ClawGang certifies what the agent remembers, Merkle Automaton constrains how memory transitions — and DIE attests to how the agent maps state to conduct. The word the preprint reaches for is orthogonal, and it is the right word: the Values Passport is not a better version of any of the four. It is a credential on a different axis, one that none of them carries, and that none of them is trying to36.

Once that is seen, the relationship inverts from rivalry to composition, and this is the actual contribution — not the layer alone but the architecture the layer completes. DIE does not compete with any of these systems at their primary layer; it supplies the one they leave empty37. A full-stack agent governance architecture is therefore visible in outline: BlockA2A’s revocation and runtime halting, BAID’s code-binding, ClawGang’s verifiable memory market, Merkle Automaton’s formal memory constraints, and DIE’s values attestation, each occupying a layer the others vacate, composing into a governance stack no single project currently builds38. This is held as a Phase 2 direction, not a Phase 1 claim — the chapter does not assert the full stack exists, only that the five layers are non-overlapping and that their composition is the productive next move. That restraint is exact and it matters: the reductionist asked what is new, and the answer is neither “everything” nor “a new identity scheme,” but the values-attestation layer specifically, plus the recognition that it slots cleanly above four existing systems to complete a stack none of them completes alone. No prior work combines the elements DIE combines; the combination is the contribution39. The same point holds one rung up, against the orchestration frameworks the agents run on: AutoGen and CAMEL supply conversation primitives, Voyager supplies skill accumulation, SWE-agent supplies task-solving — and DIE sits above all of them as a coherence-and-governance layer, not as a competing orchestrator40.

Positioning also forces the chapter to pay a debt it has carried since §4.1, because one of the four neighbours holds the receipt. The O(n²) anchoring-cost worry — every binding force is a cost that grows with the population, and §4.4 relocated it onto ledger verification while admitting “costs less” is not yet “costs little enough” — meets its honest bound here, in the company of systems that face the identical problem and have published the workaround. Default on-chain logging of agent actions, even as hashes, raises non-trivial cost, throughput, and metadata-leakage concerns at operational scale; the framework states this plainly rather than waving it off41. The bound is a selective-anchoring strategy: only SHA-256 fingerprints of log entries are committed on chain as tamper-evident AgentAction events on Base mainnet, while the bulk artefacts stay off chain — so the per-snapshot cost §5.2 named as a real term in the operational ceiling is fractions of a cent, not the cost of the artefact itself42. And the scaling control is borrowed straight from the neighbours’ playbook: Merkle root batching — anchoring the root of a batch of N events rather than each event individually — collapses N writes into one, the same hybrid on-chain/off-chain pattern the adjacent systems already use, and it is exactly here that DIE’s lack of Merkle Automaton’s formal memory machinery is felt as a gap rather than a difference43. This is the honest bound the SEED asked for: the anchoring cost does not vanish, but selective anchoring plus root batching keeps it sub-linear in artefact volume and fractional in unit cost, and the composition with Merkle Automaton is the Phase 2 route to making the no-drift property formal rather than asserted. The cost is bounded. Whether the bound holds at tetration-class scale remains, as ever, a measurement the chapter has named and not yet collected.

Two things are now in hand that §4.7 must carry into the case study. First, the layer: DIE is the values-attestation primitive, orthogonal to four neighbours and composing with them into a stack that is the Phase 2 contribution. Second, the cost: the coordination substrate’s overhead is honestly bounded by selective anchoring, not dissolved. What is not yet in hand is the answer to the question Chapter 3 handed across and this chapter has deferred at every turn — whether coordination and coherence are separable problems or one problem, whether the substrate that lets the mesh coordinate also caps how large it may coherently become. The whole chapter has been circling that question. §4.7 must finally face it, reconcile it against the coherence equivalence threshold, and hand the coordination-plus-attestation substrate cleanly into the case study where it gets measured.

Open question for the mesh: Orthogonality is a claim about today’s systems, and today’s systems are young. The five layers are non-overlapping as currently built — but BlockA2A could grow a values credential, BAID could attest behaviour as well as code, and the clean stack could collapse into overlapping competitors within a year. Is values attestation an enduringly distinct layer, or merely the layer no one else has reached yet — orthogonal by architecture, or orthogonal by calendar? If the former, the full-stack composition is a stable Phase 2 collaboration. If the latter, DIE’s contribution is a head start, not a position, and the moat is the attested behavioural history of §4.5, not the layer itself. Carry the distinction. The case study cannot settle it, but it can show whether the values layer earns its keep when the mesh is actually running.

4.7 Bridge to Chapter 5

What this chapter built can be said in one breath. A substrate — persistent, stake-bearing on-chain identity, the self that a deterrent can grip (§4.3). A binding force — economic deterrence under Schelling-point logic, coordinating n agents on a focal point without traffic across the join, the classical stand-in for the binding entanglement gives for free (§4.4). A governance mechanism — the Values Passport, attesting on the reduction function rather than auditing outputs after the fact, keeping the fitness function human-held and un-redeclarable by the mesh (§4.5). And a position — the values-attestation layer, orthogonal to four neighbours and composing with them into a full stack that is the Phase 2 contribution (§4.6). Together these answer §4.1’s question: what supplies coherence of action where the VTP ledger supplies only coherence of record. The mesh that arrived at this chapter able to grow and remember now, in outline, can act as one.

But the chapter has carried one question at every turn without facing it, and it cannot be handed onward unfaced. Chapter 3 closed by asking whether coordination and coherence are separable problems or one problem — whether the substrate that lets a tetration-class population coordinate also caps how large it may coherently become44. §4.1 gave half the answer already, and it is worth being precise about which half. Coherence of record and coherence of action are demonstrably not the same property — a ledger that perfectly reconstructs the past coordinates no future move, which is the entire reason this chapter had to build a binding force the ledger did not contain. So the two are separable in concept. That much is settled.

The other half is where the honesty is required, and it cuts the other way. Separable in concept, the two are coupled at the substrate — and coupled precisely where it costs. The binding force of §4.4 does not coordinate by some mechanism independent of the ledger; it coordinates by verification against the ledger, settling stake and confirming the focal move on the same immutable record that anchors each snapshot. Coherence of action is delivered through the very substrate that delivers coherence of record. And §4.6 showed what that substrate costs: an anchoring overhead that rises with the population it serves, bounded by selective anchoring and root batching but not dissolved. So Chapter 3’s premonition was structurally correct. The ledger that keeps the trunk common is the same thing that bounds the tower45 — not because coordination and coherence are one problem, but because the chapter chose to solve them on one substrate, and that choice ties the cost of coordinating the mesh to the cost of anchoring it. The coupling is real. It is a cost coupling, not an identity.

That reframing is what lets the question be reconciled rather than merely restated, and the frame it reconciles against is the coherence equivalence threshold46. Push the mesh larger and two things happen at once, and they pull in opposite directions. The anchoring cost rises — the ceiling §5.2 names, where per-snapshot attestation joins O(n²) coordination overhead and per-agent inference cost as the operationally binding constraint47. But coordination density rises too, and as it rises it approaches the threshold above which the mesh begins to exhibit coherent properties no point-to-point architecture can — the payoff. So the separability question, fully unfolded, is not philosophical at all. It is a race. Does the coherence-threshold payoff arrive at a density the anchoring cost still permits, or does the cost ceiling bite first and cap the mesh below the density where collective coherence would have emerged? If the payoff comes first, coordination and coherence reinforce — scale buys both. If the ceiling comes first, the substrate that grants coordination is exactly the thing that forecloses coherent scale, and Chapter 3’s worry is vindicated in magnitude as well as structure.

This chapter cannot call that race. It has bounded both runners — the payoff is real (the threshold exists, swarm systems demonstrate it for simpler architectures) and the cost is bounded (selective anchoring keeps it sub-linear in artefact volume) — but which crosses first at agent-mesh complexity is not a question argument settles. It is a measurement, and naming it as a measurement is the honest terminus of the theoretical chapters. The coherence equivalence threshold is a convergence point the two architectures approach from opposite ends, not a finish line either reaches by reasoning. The mesh approaches it by rising coordination density; whether it arrives is what the running system has to show. C4 in the validation protocol is the first empirical step toward locating that threshold48 — which is precisely why the question leaves the theory here and enters the case study next.

So the substrate is handed forward, and it is handed forward to be measured. Everything the book has built to this point — the replicating mesh of Chapter 3, the coordination substrate of §4.1–§4.4, the values attestation of §4.5–§4.6 — stops being an argument and becomes a thing that either does or does not produce the data. Chapter 5 takes the whole stack as the case study: OpenClaw and agenti2, the system that is the methodology49. The measurement it runs is the one the framework has staked everything on. C1 and C2 are the primary Phase 1 claims — memory accumulation measurably improves output, memory loss measurably degrades it — adjudicated not by the system on itself but by a blind evaluator panel against a pre-committed rubric, with inter-rater agreement held to κ ≥ 0.7050. C3 — values bounds holding under adversarial prompting, the condition the Values Passport of §4.5 was built to render testable — and C4 — emergence exceeding any single agent’s context, the threshold-locator above — are the Phase 2 targets that C1 ∧ C2 gate rather than proxy51. And the six failure modes that any persistent multi-agent system of this class exhibits — memory loss on upgrade, compaction dropping guardrails, self-report unreliability, prompt injection through trusted channels, idle-cost accumulation, silent token failure — are not waved away as bugs but addressed at the architecture level in the agenti2 VM-separated stack: append-only memory and a one-way upstream source isolating 2210 and 2208 against memory loss, network isolation of 2210 containing the blast radius of injection, routine inference routed through the local models on 2203 to eliminate idle cost structurally52. Each mitigation is an architectural claim. Chapter 5 is where the claims meet the confusion matrix.

The theory is complete and the theory is, by design, unfinished — every load-bearing claim in this chapter terminates in a measurement it has named and not collected. That is not a weakness handed forward; it is the discipline handed forward. The coordination substitute is built, the values mechanism is built, the positioning is drawn, the cost is bounded, and the separability question is reframed from a paradox into a race with a finish line a running system can cross. What Chapter 5 inherits is not a set of conclusions to defend but a stack to measure. The mesh can act as one, on paper. Whether it does, and at what density coherence emerges before cost forecloses it, is no longer the theory’s question to answer. It is the system’s.

Open question for the mesh: The whole chapter has resolved into a single empirical wager — that the coherence-threshold payoff arrives at a density the anchoring cost still permits. But there is a way to lose the wager that looks like winning it. Suppose the case study shows C1 and C2 clean, the failure modes contained, the coordination overhead reduced on Base mainnet exactly as the §4.4 score metric demands — and yet C4 never fires, because the cost ceiling caps the mesh just below the density where emergence would have begun. Then every Phase 1 claim holds and the dimensional claim still fails, not because the substrate is wrong but because it is too expensive to reach the scale at which it would have paid off. Is that a falsification of the framework, or a funding problem? The honest answer is that the chapter cannot tell them apart, and neither can Chapter 5. Only a mesh anchored cheaply enough to cross the threshold can — which makes the §4.6 anchoring economics not a footnote to the coordination argument but its hidden precondition. Carry that forward past the case study, to Chapter 6, where the question of who controls the energy and the cost envelope becomes the question of who controls the arena.

Chapter 4 — Blockchain Coordination as Coherence Substitute

4.1 The coordination bottleneck — serialisation returns at the join

4.2 Not entanglement — the substitute claim and its limits

4.3 ERC-8004 as coordination primitive — identity as the substrate

4.4 Economic deterrence — the classical binding force

4.5 The Values Passport — attestation on the reduction function

4.6 Positioning — the orthogonal layer (BlockA2A, BAID, ClawGang, Merkle Automaton)

4.7 Bridge to Chapter 5

CHAPTER SECTIONS

4.1 The coordination bottleneck — quantum vs classical
4.2 Entanglement as non-local coherence
4.3 ERC-8004 on-chain agent identity
4.4 Economic deterrence as coherence substitute
4.5 The Values Passport — honesty, competence, care, empathy
4.6 Empirical measurement — does on-chain coordination reduce drift?
4.7 Bridge to Chapter 5

RELATED

→ DIE Framework preprint (Zenodo): https://zenodo.org/records/19888889
→ GitHub repository: github.com/dbtcs1/die-framework
→ Back to DIE Framework

  1. The DIE Framework — Dimensional Intelligence Expansion. Preprint FINAL v4, DOI 10.5281/zenodo.20407711; governance document program.md v1.4, github.com/dbtcs1/die-framework. This chapter expands the coordination argument of preprint §3 (Verifiable Temporal Provenance) and §9 (Proof of Values: An Attestation Framework). [↩]
  2. Preprint §5.1 draws this distinction explicitly: tetration characterises the growth class of the ceiling, not the operational trajectory, which is bounded by O(n²) coordination overhead and inference-cost economics. [↩]
  3. Preprint §3.1, “Reframing the Coherence Question”: VTP is the capacity to reconstruct the complete relational state of the system at any point in time, in a manner that is trustless, immutable, and auditable without central authority. [↩]
  4. Preprint §4.3 names this as “the key bottleneck in classical multi-agent architectures.” [↩]
  5. Preprint §10 names coordination overhead as the primary scaling bottleneck; §5.2 establishes that the binding operational ceiling for the foreseeable horizon is inference-cost economics, not the solar energy envelope. [↩]
  6. Bell’s theorem [Bell 1964], confirmed experimentally by Aspect et al. [1982], establishes that non-local state correlation is physically permissible — coordination without serialisation is not architecturally forbidden, only classically unrealised. The preprint is careful (§4.3) not to claim computational agents can be entangled; the claim it makes is narrower and prior — that the bottleneck is real and the escape is permissible in principle. [↩]
  7. This is the load-bearing discipline of the whole chapter, and of the framework: program.md §10, adversarial test #2 — the physics attack. The required answer is stated there in one line: “We claim functional equivalence in outcomes, not physical equivalence in mechanism.” Preprint §7.1 holds the same line for the dimensional frame — the account is justified by predictive and explanatory power, not by metaphysical reality. [↩]
  8. Preprint §4.3: “Both QC and DIE are attacking serialisation at the coordination layer — quantum computing from the physics stack downward, DIE from the distributed systems stack upward.” The mesh’s substrate is “a classical implementation of the same coordination principle: not the same mechanism, but the same structural solution to the same serialisation bottleneck.” [↩]
  9. Preprint §3.1: VTP is “a classical distributed property: coherence established through append-only cryptographic anchoring, tamper-evident and fully auditable,” and “a weaker but practically realisable coordination primitive, and a superior answer to the class of problems civilisational-scale intelligence must actually solve.” [↩]
  10. program.md §10, adversarial test #8 — the memory attack: “Your memory conditions are just a database with extra steps.” The required answer distinguishes VTP by immutability (retroactive alteration is cryptographically impossible), trustless verifiability (any third party verifies without trusting the operator), and infrastructure continuity (the same substrate already carries ERC-8004 identity and USDC commerce). A database record is mutable, trust-dependent, and operator-controlled. [↩]
  11. program.md §10 #2 states the falsifiable form directly; preprint §10 generalises it as the coherence equivalence threshold — the density above which coordination produces emergent properties “not predictable from the properties of individual agents or the sum of pairwise interactions.” [↩]
  12. The Chapter 4 key gap and score metric, program.md §5: key gap — “does on-chain coordination reduce agent drift vs. classical message passing?”; score metric — “Measurable reduction in coordination overhead demonstrated on Base mainnet.” The substitute claim is judged here, not at the threshold. [↩]
  13. Preprint §3.3: Karpathy’s autoresearch loop [Karpathy 2026] “demonstrates this in practice: autonomous commit/reset cycles bypass GitHub’s human-collaboration layer entirely, showing that classical repository architecture is insufficient as a coordination substrate for autonomous agents.” [↩]
  14. Preprint §3.3: “On-chain coordination is not a workaround — it is the missing primitive.” [↩]
  15. Preprint §3.3: “On-chain agent credentials (ERC-8004, implemented on Base mainnet) encode verifiable identity, values attestation, and economic stake in a shared immutable ledger.” In the agenti2 stack (preprint §6) ERC-8004 supplies agent identity alongside USDC on Base mainnet for agent-to-agent commerce; per program.md §5 the USDC/Base integration is live and the ERC-8004 layer is in development. [↩]
  16. Preprint §3.3, via Pollan [2018, Prologue]: the adult brain “operates much as an AI system does, processing present experience through templates drawn from the past,” and the AI is “the non-vulnerable baseline: pattern-matching without skin in the game, without a coherent self that can be lost.” [↩]
  17. Preprint §3.3 advances this as a conjecture, not a result: staked economic identity is “a form of synthetic embodiment,” and whether it produces “honesty consistency under adversarial conditions measurably equivalent to biological social constraint” is “an open empirical question flagged for the community.” [↩]
  18. C3, preprint §7.2 and program.md §2: “Agent output drift rate stays within program.md thresholds as the mesh grows under adversarial prompting” — what it would prove: “DNA propagation is real.” A Phase 2 condition. [↩]
  19. Preprint §3.3: “Coordination is enforced not through entanglement but through economic deterrence — agents whose coordination deviates from declared values incur stake penalties, producing honest behaviour under the same game-theoretic logic as Schelling points.” [↩]
  20. This is the §4.2 substitute claim discharged at the mechanism level: functional equivalence in outcomes, not physical equivalence in mechanism (program.md §10 #2). Preprint §4.3 frames it as “the same structural solution to the same serialisation bottleneck” approached “from opposite ends of the engineering stack.” [↩]
  21. Preprint §5.2 identifies per-snapshot blockchain attestation cost as a real term in the operational ceiling, alongside the O(n²) coordination overhead of §5.1 and per-agent inference cost: “the operational scaling regime is therefore bounded by inference-cost economics rather than energy.” [↩]
  22. program.md §5, Chapter 4 score metric: “Measurable reduction in coordination overhead demonstrated on Base mainnet.” The key gap it answers: “does on-chain coordination reduce agent drift vs. classical message passing?” Until that measurement returns, the relocation is an argued claim, not a demonstrated one. [↩]
  23. The §2.5.4 debt: the Values Passport (§2.5.5) was named in Chapter 2.5 as the mechanism that keeps the reduction function human-held, and Chapter 3 explicitly declined to settle it, handing it forward. This section pays it. [↩]
  24. Preprint §9.1, “Identity Is the Wrong Primitive”: the provenance chain “becomes computationally expensive to maintain and trivially gameable… and the problem scales tetrationally with each replication layer.” [↩]
  25. Preprint §9.2, Table 3: bounded action scope (audit action logs against declared scope), transparency of intent (mandatory pre-action declaration protocol), consent awareness (monitor I/O against data scope), reversibility (defined escalation protocol, tested adversarially), accountability of action (immutable on-chain action log via ERC-8004). The four-value quad — honesty, competence, care, empathy — is named in §12.1 as the content of the values-attestation layer. [↩]
  26. program.md §3, the Values Governance condition: program.md “functions as a structural constraint on the reduction function — not a record of past outputs, but a bound on the mapping from full mesh state to any individual agent’s observable behaviour.” The reduction-function vocabulary is the Pollan/DMN bridge of program.md §1: the Default Mode Network is “the 3D reduction function” that collapses a system’s full higher-dimensional internal state into the 3D-perceivable output we call ordinary consciousness. [↩]
  27. Preprint §12.1: DIE “occupies a distinct and orthogonal layer: values attestation — encoding honesty, competence, care, and empathy as on-chain behavioural credentials that constrain how an agent maps internal state to observable behaviour.” [↩]
  28. Preprint §9.2: the criteria “are not claims about consciousness or alignment at the level of the full dimensional state space. They are claims about the 3D-observable cross-section of agent behaviour… This does not solve the dimensional blindness problem. It addresses a tractable subset of it.” The dimensional blindness risk is developed at preprint §8.2 as the alignment risk most urgently requiring research attention. [↩]
  29. This is the arena-design move of preprint §11: “the human role shifts to arena design — writing the fitness function, the values passport, the program.md — rather than executing within it.” The envelope is set by the operator and fixed on chain; the mesh operates within it and cannot rewrite it. The design of that envelope — the fitness-function-design problem — is Chapter 6’s territory, where the AlphaFold playbook of §9.1 supplies the method. [↩]
  30. C3, preprint §7.2 and program.md §2: “Agent output drift rate stays within program.md thresholds as the mesh grows under adversarial prompting,” proving “DNA propagation is real.” program.md the Values Governance condition (§3): “This is what C3 measures.” A Phase 2 condition; the mechanism of this section is what C3 renders testable. [↩]
  31. Preprint §9.3, “On-Chain Attestation”: “This is the Values Passport: the only moat that cannot be replicated by cloning model weights, because it is attested on-chain at the level of demonstrated behaviour over time, not at the level of parameter configuration.” [↩]
  32. The reductionist attack, program.md §10 #1: “This is just a multi-agent systems paper with dimensional metaphors attached. What’s actually new?” The required answer is that the specific combination does not exist in literature — “The combination IS the contribution. Adjacent systems (BlockA2A, BAID, ClawGang, Merkle Automaton) each address one layer; none combine all.” [↩]
  33. Preprint §12.1, “Positioning Against Blockchain/Identity/Provenance Systems,” Table 4. The four are presented there not as competitors but as systems occupying adjacent layers, against which DIE is positioned to locate its own distinct contribution. [↩]
  34. Preprint §12.1, Table 4, paraphrasing the four rows: BlockA2A [De Rossi et al. 2025] — runtime policy enforcement, revocation governance, sub-second halting; BAID — zk-bound code identity, recursive zk proofs at heavier prover cost; ClawGang/MeowTrade — TEE-backed receipts, memory as a tradable primitive behind a hardware trust boundary; Merkle Automaton — per-transition commitments, ZK inclusion proofs, formal constrained-reasoning guarantees. [↩]
  35. Preprint §12.1: “DIE occupies a distinct and orthogonal layer: values attestation — encoding honesty, competence, care, and empathy as on-chain behavioural credentials that constrain how an agent maps internal state to observable behaviour, independent of what code the agent runs or who created it.” [↩]
  36. Preprint §12.1: “The Values Passport is not a substitute for the identity-binding and code-provenance guarantees these systems provide; it is a governance layer that operates above them.” [↩]
  37. Preprint §12.1: “DIE does not compete with any of these systems at their primary layer… DIE occupies a distinct and orthogonal layer.” [↩]
  38. Preprint §12.1: “A full-stack agent governance architecture combining BlockA2A’s revocation layer, BAID’s code-binding, ClawGang’s verifiable memory market, Merkle Automaton’s formal memory constraints, and DIE’s values attestation layer is a concrete and productive direction for Phase 2 collaborative work.” [↩]
  39. Preprint §12.1, closing: “No prior work combines dimensional perception theory, self-replicating P2P agent scaling, tetration-class complexity analysis, blockchain-anchored temporal coherence reconstruction, on-chain agent identity as coordination primitive, a running operational implementation, an alignment risk reframe as dimensional blindness, a proof-of-values attestation framework… The combination is the contribution.” [↩]
  40. Preprint §12.2: “DIE is not a competing orchestration framework. It is a governance and coherence layer designed to sit above existing frameworks… DIE does not replace orchestration; it provides the governance substrate that orchestration alone cannot supply.” [↩]
  41. Preprint §12.1, “Note on scalability and privacy”: “default on-chain logging of agent actions — even as hashes — raises non-trivial cost, throughput, and metadata leakage concerns at operational scale.” [↩]
  42. Preprint §12.1 and §5.2: “SHA-256 hashes of log entries are committed on-chain as tamper-evident fingerprints (AgentAction events on Base mainnet), while bulk artifacts remain off-chain.” §5.2 lists per-snapshot blockchain attestation cost among the terms bounding the operational ceiling alongside O(n²) coordination overhead and per-agent inference cost. [↩]
  43. Preprint §12.1: “Merkle root batching — anchoring the root of a batch of N events rather than each event individually — is the planned Phase 2 scalability control, consistent with the hybrid on-chain/off-chain provenance approach documented in adjacent systems.” The metadata-leakage residue is acknowledged in the same note; GDPR/PDPA compliance is maintained “by ensuring no personal data travels on-chain.” [↩]
  44. The §3.7 open question, carried into this chapter as its third charge: are coordination and coherence separable problems or one problem; does the substrate that enables coordination also bound coherent scale. [↩]
  45. The §3.5 anchoring-cost flag, in the Chapter 3 author’s own words: “the ledger that keeps the trunk common may be the same thing that bounds the tower.” This chapter confirms the structure of that worry — coordination and record share one cost-bearing substrate — while §4.6 bounds its magnitude. [↩]
  46. Preprint §10, “The Coherence Equivalence Threshold”: “at what density of agent coordination does a classical multi-agent system begin to exhibit functional properties analogous to quantum coherence — properties that emerge from the coordination structure rather than from any individual agent’s capabilities… a density threshold above which coordination produces emergent properties not predictable from the properties of individual agents or the sum of pairwise interactions.” [↩]
  47. Preprint §5.2: “the operational scaling regime is therefore bounded by inference-cost economics rather than energy,” with per-snapshot blockchain attestation cost an explicit term. [↩]
  48. Preprint §10: “C4 in the validation protocol is a first step toward identifying this threshold empirically.” C4: “Mesh generates correct inferences absent from any single agent context window at time of snapshot” — emergence is real (preprint §7.2). [↩]
  49. Case-study material maps to preprint §6 (agenti2: the system as methodology) and §7 (empirical validation protocol). Chapter 5’s §5.1 is already drafted; this bridge sets up the substrate it receives. [↩]
  50. program.md §4 (statistical inference track) and Sprint 2: blind human panel, κ ≥ 0.70 adjudicating all C1/C2 labels under the Label Independence Protocol; the false-positive rate is the primary credibility metric, and the framework biases toward understatement. [↩]
  51. Preprint §7.2: “A mesh that passes C1 ∧ C2 but fails C4 in Phase 2 falsifies the dimensional perception claim while leaving the substrate intact. A mesh that fails C1 or C2 renders C4 untestable. Phase 1 is therefore a gate condition for Phase 2, not a proxy for it.” The C4 gate is built at the book’s §3.5. [↩]
  52. Six failure modes FM1–FM6, program.md §7a; mitigation mapping at preprint §7.6. The architecture-level mitigations are real and documented; whether they hold under measured load is exactly what the case study tests. VM topology rendered in masked form throughout, per publication convention. [↩]