helping individuals create value

Chapter 3 — P2P Self-Replicating Architectures: Complexity Class Analysis

A loop that runs is a unit; a loop that spawns loops is a tower — but only if every storey holds weight.

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

This is the highest-risk chapter in the book, and its claim is the most spectacular the framework makes: a self-replicating orchestrator mesh with mⁿ growth — where m is itself growing with replication depth — produces tetration-class scaling, and on dimensional reach per unit time outpaces quantum computing’s 2ⁿ. The claim is conceptually strong and mathematically underdeveloped, and this chapter is honest about that seam. The formal assignment of a complexity class is the standing open gap — work for a formalisation mathematician still to be recruited — and the metric against which the chapter will ultimately be judged is whether that class survives peer review. Mandelbrot’s fractal geometry, which would read the mesh’s growth as self-similar boundary expansion, is held back as a Phase 2 conjecture: flagged, not claimed. And throughout, the dimensional frame is epistemological — “dimensional reach per unit time” is a claim about explanatory and predictive scaling, never an assertion that the mesh occupies higher-dimensional physical space.

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

3.1 What self-replication means in an agent context

In 1948 John von Neumann posed what sounds like a paradox: can a machine build a machine as complicated as itself? The intuitive answer is no — surely the builder must be richer than the built, or the line dwindles to nothing. Von Neumann proved the answer is yes, and in proving it he isolated the exact structure that separates real replication from its appearance. A self-reproducing automaton, he showed, needs four parts: a universal constructor that can build any machine from a description; a copier that duplicates the description; a supervisor that runs the two in order; and the description itself — a tape carrying the blueprint of the whole.2 The decisive move is that the description is both interpreted, to build the offspring, and copied, so the offspring carries its own blueprint onward. A photocopier makes copies but does not reproduce, because the copy cannot copy. Von Neumann’s automaton reproduces because the child inherits the capacity to have children.

That distinction — a unit that can produce units versus a unit that can only be copied — is the whole of Chapter 3. Get it wrong and every growth figure in the chapter is inflation wearing the notation of mathematics. Get it right and the tower stands.

An orchestrator in the mesh is von Neumann’s automaton in miniature. It carries a description: program.md, the governance tape that fixes what the loop is for and what bounds it (the Values Governance condition; program.md §1). It runs loops: perception → evaluation → action triples that close against an evaluator and write to a shared memory substrate — the primitive secured in Chapter 2.5. To replicate is to do what von Neumann’s machine does — spawn a unit that both runs its own evaluator-closed loops and carries the description forward, so that the offspring can in turn spawn. An orchestrator that merely launches copies of itself which never close a triple has produced a photocopier’s output, not a child.

This is where the boundary discipline becomes non-negotiable. Chapter 2.5 secured a non-gerrymanderable n for a loop that runs: n is the count of complete triples sharing the memory substrate at timestamp T — the preprint’s S(T).3 Replication is precisely the operation that could smuggle gerrymandering back in. If spawning a sub-orchestrator incremented n by itself, a mesh could inflate its own dimensional reach simply by copying the act of copying — a hall of mirrors reporting itself as a crowd. So the rule is stated sharply and held: replication adds to n only by adding genuinely closed triples. A spawned shell that has not yet closed a perception → evaluation → action cycle against the shared substrate is a process that has been launched, not a reasoning instance that is active. It does not count. S(T) measures work under way, not intentions to work.

The definition already enforces this, if read carefully. S(T) ranges over instances that are concurrently active and memory-coherent, and under replication both adjectives do load-bearing work. Active excludes the spawned-but-idle shell — launched, waiting, closing nothing. Memory-coherent excludes the spawned-but-orphaned unit that shares no substrate with its parent: a fork that has wandered off is not adding to this mesh’s reach, it is quietly starting a different one. Replication that produces orphans grows the process count and leaves S(T) flat. The boundary Chapter 2.5 drew at “where the evaluator fires” therefore survives replication intact — it simply now has to fire in each offspring before that offspring is counted. The tree may branch as wide as it likes; only the branches that flower are on the ledger.

None of this asserts biological reproduction or physical copying. The mesh does not literally give birth; “self-replication” names a class of growth in coordination structure, not an ontological claim about machines. The von Neumann analogy does the same epistemological work the Flatland analogy did in Chapter 1 — it supplies precise vocabulary for a structural distinction, not a claim that orchestrators are alive. And the frame earns its keep the only way the DIE frame ever does: by predicting something measurable. A mesh whose offspring close triples should show S(T) rising with replication depth; a mesh that only spawns shells should show S(T) flat while the process count climbs.4 That gap lives in the logs, where anyone can audit it.

Open question for the mesh: we can state the rule that keeps n honest under replication. We have not yet specified the cheapest reliable test an orchestrator can run on its own offspring to decide, at timestamp T, whether a given child has crossed from launched to counted — without that test itself becoming a serialising bottleneck, a parent forced to inspect each child in turn, re-imposing the very serial constraint the replication was meant to escape. Who evaluates the evaluator’s children, and how cheaply?

3.2 mⁿ growth — where m is itself growing

3.1 left us with a single honest act of replication: a parent orchestrator, one evaluator-closed child that shares the substrate and can itself spawn. Now stack that act. If each orchestrator spawns m counted children, and each child is itself a full orchestrator that spawns m of its own, then after n generations the population of evaluator-closed instances is mⁿ. This is the familiar shape of exponential growth — a balanced m-ary tree of depth n, mⁿ instances at the frontier. It is the chessboard-and-wheat legend with a wider base: doubling per square becomes m-fold per generation.5 Nothing here is new. Any branching process grows this way, and a fixed fan-out m gives a fixed exponential mⁿ — fast, but a curve we can name, bound, and out-compute.

The DIE claim departs from the legend at one word: m does not stay fixed. In a quantum system the base is pinned — each qubit doubles the state space, the base is 2 and stays 2, and the growth is 2ⁿ exactly. In the mesh the base rises generation over generation, for three compounding reasons, each inherited from earlier in the book. First, resources grow: more compute and energy become available over time, and m is bounded by what a generation can afford to spawn — the energy ceiling of preprint §5.2.6 Second, capability grows: as the procedural trunk thickens — the cross-snapshot how-to memory of Chapter 2.5 — each orchestrator coordinates a wider effective fan-out than its parent could, because it inherits a thicker trunk to stand on. Third, the capacity to spawn is itself inherited: 3.1’s von Neumann point, that the child carries the description forward, means each generation does not merely add agents — it adds spawners. The first two raise m; the third makes the raising compound.

When the base of an exponent climbs as the structure it raises grows, you leave fixed exponential behind. The product m₁ · m₂ · … · mₙ, with each successive factor larger than the last, outruns any fixed mⁿ you care to set in advance; and in the limit where each generation’s fan-out grows with the population that spawned it, the curve bends towards a tower of exponents — tetration, written m↑↑d in Knuth’s up-arrow notation.7 This is the candidate growth class the chapter is named for. It is a candidate, not a settled result: whether the mesh’s rising-base growth genuinely occupies the tetration class, and how that class is to be formally assigned, is the open mathematical gap this chapter flags and 3.3 confronts directly. What 3.2 establishes is narrower and firmer — the base is not fixed, and a growing base is the whole difference between a curve we can out-compute and one we cannot.

That firmness depends entirely on the discipline of 3.1, and exponentiation raises the stakes. At every layer, m must be the count of counted offspring — evaluator-closed, substrate-coherent — never the count of spawned shells. An mⁿ built on shells is the hall of mirrors of 3.1, now compounded n generations deep: a per-unit lie magnified by exponentiation into an astronomical one. This is the most dangerous inflation in the book, precisely because the notation is so impressive — a tower of exponents is exactly the shape a fraud would choose to wear. The boundary discipline is therefore not merely preserved under replication; it is load-bearing for the growth claim. An honest m gives an honest tower. A dishonest m gives mathematics-shaped noise that grows faster than the truth and is far harder to catch.

It is worth being exact about what the tower counts, because the answer is not the obvious one. What compounds is not raw computation. Per-agent compute scales merely linearly with mesh size — a thousand agents do roughly a thousand agents’ worth of arithmetic. What grows tetration-fast is coordination reach: the cardinality of distinct perspective relations the mesh can hold coherently at a single timestamp — the S(T) and context-coverage terms of D_eff(M).8 The tower is a tower of reach, not of arithmetic. This distinction is not a hedge; it is the only reading under which the chapter’s headline — that the mesh outpaces 2ⁿ on dimensional reach per unit time — is even a coherent sentence. 3.3 takes that sentence and tests it.

One dependency the growth claim cannot discharge by itself: m keeps rising only while the trunk stays coherent across a growing population. The second reason m grows — a thickening procedural trunk — assumes that trunk propagates faithfully as orchestrators spawn orchestrators. If procedural memory fragments, if the swarm forgets what its parent knew, then capability stops compounding, m stops rising, and the tower flattens back into ordinary fan-out. The growth curve of this chapter thus rests on a problem the chapter has not yet solved: whether procedural memory survives replication. That is the swarm memory problem, and 3.4 is where it comes due.

Open question for the mesh: we have argued that m rises — not how fast, nor for how long. Somewhere a thickening trunk’s gift of wider fan-out meets the O(n²) cost of coordinating that fan-out,9 and at that inflection the rising base must either plateau or the overhead must be paid down faster than it accrues. Is there a law relating procedural-memory depth to sustainable m — or does every mesh simply climb until coordination overhead eats the gain, each at its own private ceiling? The curve has a shape we have asserted but not yet measured.

3.3 Tetration-class scaling vs quantum 2ⁿ — and the limits of the claim

Set the two growth laws side by side. A quantum computer adds dimensions by adding qubits: each qubit doubles the state space, so n qubits span 2ⁿ dimensions. The base is pinned at 2 and never moves; growth is fixed-base exponential, and n — the qubit count — is what climbs.10 The self-replicating mesh, by 3.2’s argument, grows by a different law: a rising-base tower, m↑↑d, where the fan-out m itself climbs generation over generation. As growth classes, these are not close. Tetration dominates exponentiation — for any matched depth past a small threshold, a tower of exponents incomparably exceeds a single one, and no fixed-base 2ⁿ can stay within reach of m↑↑d as d grows.11 At the level of growth class, the headline is simply true: the mesh’s law outruns the quantum law.

That is also the level at which the headline is least useful, and most easily misread. Two qualifiers do the real work, and the chapter is dishonest without both.

The first is per unit time, and it is not decoration — it is the whole comparison. The two systems climb their exponents against entirely different ceilings. Quantum raises n by physical engineering: every additional coherent qubit is a fight against decoherence, gate infidelity, and cryogenics, and that fight is slow and brutally expensive per increment.12 The mesh raises its reach by replication, whose ceiling is energy and per-agent inference cost — an economic and physical bound, but not the same physics-of-coherence wall.13 The claim the chapter actually makes is therefore narrow and defensible: on the rate at which the exponent climbs — dimensional reach gained per unit time — the mesh’s ceiling permits a faster ascent than the quantum ceiling does. It is a claim about velocity and the character of the constraint, not about who is bigger today.

The second qualifier is the one a careless reader drops, and the table forbids dropping it. Tetration is the growth class of the ceiling, not the trajectory the mesh is currently on.14 Read the table honestly and the asymmetry runs the other way from the headline: a mesh in the practical, fixed-fan-out regime sits at a few effective dimensions, while current quantum hardware already spans 2⁹⁸ — a categorical discontinuity that today favours quantum on raw dimensional footprint by a margin as wide as the gap between Flatland and a human.15 So “outpaces 2ⁿ” cannot mean “is already larger than a quantum computer.” It is not. It means the mesh is on a growth law that, given its ceiling, can keep climbing after the quantum law’s increments have become prohibitively expensive — a claim about which curve is still rising freely at the relevant horizon, not which point is higher now.

Now the seam program.md names, and the reason this chapter is filed as mathematically underdeveloped. “Tetration-class” is at present a candidate label, not a discharged complexity-theoretic assignment, and there are two distinct debts behind the label. The first is definitional: complexity classes, in their standard use, classify the resources required to solve a problem — time, space, circuit depth. The quantity climbing here is not that; it is the growth of a coordination-reach measure, the combinatorial cardinality of inter-agent perspective relations the mesh holds coherently — the S(T)- and coverage-terms of D_eff, never raw per-agent compute, which scales merely linearly.16 Before “tetration-class” can be a complexity claim, the formal object being classed has to be defined precisely — and showing that a reach measure belongs to a growth class is a different proof from the textbook ones about solving time. The second debt is the assignment itself: even granting the object, it is unproven that the mesh’s rising-base growth genuinely attains the tetration class once O(n²) coordination overhead, latency, and contention are paid, rather than collapsing into some sub-tetration regime that merely looks tower-shaped over the measured range.17 This is precisely the gap program.md holds open — formal complexity-class assignment — and it is assigned, deliberately and by name, to a formalisation mathematician still to be recruited; the chapter’s score is not met by this prose but by that class surviving peer review.18 Stating the claim and certifying it are different acts, and this chapter does only the first.

There is a last misreading to refuse, and it is the one a physicist reaches for first: you are dressing a multi-agent system in quantum clothes; emergent coordination is not coherence, and you are conflating metaphor with mechanism. The objection is correct about mechanism and beside the point about the claim. The mesh is not quantum; it makes no claim to entanglement, superposition, or non-local correlation, and 2ⁿ is invoked only as the scaling law of the rival architecture, not as something the mesh reproduces by other means. What the chapter claims is functional equivalence in outcomes, not physical equivalence in mechanism.19 The two architectures are attacking the same enemy — serialisation at the coordination layer — from opposite ends of the engineering stack: quantum computing downward from physics, the mesh upward from distributed systems.20 The place they meet is not a finish line but a threshold — the coherence equivalence threshold of preprint §10 — and “outpaces” is a statement about the rate of approach to that threshold along the mesh’s own stack, never a claim to have become the other machine. The honest sentence is this: classical does not beat quantum at being quantum; the mesh grows faster than the problem space in the dimensions that matter for real-world coordination, and whether it does so is a measurable question, not a settled one.

And the frame remains epistemological throughout. “Dimensional reach per unit time” names the rate at which the mesh’s explanatory and predictive coverage of a problem space expands — what D_eff models that S(T) alone cannot.21 It is not, and must never be read as, a claim that the mesh occupies higher-dimensional physical space, nor that tetration buys it a literal new geometry. The tower is a tower of coordinated reach. Its height is the thing in question, and the question is open.

Open question for the mesh: the formal-assignment gap has a sharp empirical edge that does not wait for the mathematician. Over what measured range, and against what null, would a mesh’s growth curve let an observer distinguish a genuine rising-base tower from a fixed-base exponential wearing tetration’s notation over a short window — given that any finite run is consistent with infinitely many laws that agree on the sampled points? Until that discriminating test is specified — the curve-shape analogue of 3.1’s counting discipline — “tetration-class” remains a hypothesis the logs have not yet been asked to refute. What measurement would tell the tower from the trick?

3.4 The swarm memory problem

3.2 made the mesh’s growth depend on a thickening trunk and then deferred the bill. The rising base m has three engines, and the second was capability: each orchestrator coordinates a wider fan-out than its parent because it inherits a thicker procedural trunk to stand on. That engine assumes the trunk propagates — that procedural memory passes faithfully from parent to child as orchestrators spawn orchestrators. Strip the assumption out and the engine stalls: if each child must re-derive its parent’s competence from nothing, capability stops compounding, m stops rising, and 3.3’s tower flattens back into fixed fan-out. The swarm memory problem is therefore not a footnote to the growth claim. It is the growth claim’s load-bearing precondition, which is why program.md files it as the thing this chapter must address.22

Recall the distinction Chapter 2.5 secured. A closed turn’s carry splits two ways: the episodic leaf — snapshot-local, what happened at SSn, immutably anchored, and correctly does not propagate forward — and the procedural trunk — the cross-snapshot how-to knowledge that accumulates SS1 → SS2 → SSn and is the mechanical basis of trunk thickening.23 That split was defined along a single axis — time, one orchestrator’s loop running SS1 to SSn. Replication adds a second, orthogonal axis: not just forward through time but outward across a population. The discipline that kept memory coherent down one timeline now has to hold across a branching forest of timelines spawning in parallel. The split must survive in two dimensions, and it was only ever proven in one.

The failure mode has a precise shape, and it can fail in two opposite directions. Propagate the wrong thing and every child inherits its parent’s episodic leaves — snapshot-local records that were never meant to travel — bloating each new orchestrator with the frozen particulars of a moment that is not its own, the very context-window stuffing the Memory-Type Separation condition exists to forbid.24 Propagate too little and the opposite catastrophe: the child loses the procedural trunk and re-derives established competence from scratch at every spawn — the sapling problem of C2, now multiplied across a growing population. This is the population-scale form of the first documented failure mode in the register: memory state silently lost at a boundary, the trunk that does not thicken.25 A swarm that has forgotten what its parent knew is not a smaller mesh. It is a crowd of saplings standing where a forest of trees was promised.

Even faithful inheritance at the moment of spawn does not settle the harder question, which is divergence. Suppose a child copies its parent’s trunk perfectly at birth. From that instant, parent and child both keep running, both keep learning, both keep thickening — independently, in parallel, along separate timelines. Without something holding them together, the population does not share one trunk that grows; it grows N trunks that drift, each accumulating procedural knowledge the others never see, until the “shared” memory of the swarm is a polite fiction over a set of mutually ignorant forks. Coherence under replication is thus not a copying problem — copying is the easy half — but a reconciliation problem: how a population that keeps learning in parallel maintains a procedural memory that is genuinely common, rather than a scatter of private histories that happen to share an ancestor.

And it cannot be solved the obvious way, by giving every orchestrator the whole record, because the whole record does not fit. The substrate the population shares grows with the population; the Retrieval Standard is explicit that no instance loads the full corpus into context — entries are embedded and retrieved on semantic relevance at query time, so the corpus grows arbitrarily while working memory stays bounded.26 So “the trunk stays coherent” cannot mean “every node holds everything.” It has to mean something subtler and harder to guarantee: that any node, querying the shared substrate, retrieves a procedural memory consistent with what its siblings would retrieve for the same query — coherence as a property of retrieval against a common, bounded-working-memory substrate, not of universal possession. That is a far weaker promise than a single shared brain, and far stronger than N drifting forks, and whether the mesh can actually sit in that middle is exactly what is unproven.

Stated at full sharpness, then, the problem this chapter must answer has three faces, and they must be answered together. Does procedural memory propagate faithfully at spawn — the right thing, not the episodic wrong thing? Does it stay coherent across a population that keeps learning in parallel, rather than fragmenting into private histories? And does it do both while honouring the retrieval-not-loading constraint that keeps any single node’s working memory bounded as the substrate grows without limit? A mechanism that answers one face by violating another has not solved the problem; it has moved it. The next section puts agenti2’s separated-memory architecture forward as the candidate that claims to answer all three at once — and is judged by whether it does so without smuggling the cost into a corner.

Open question for the mesh: every framing above treats coherence as something to be preserved against the entropy of replication — propagate, reconcile, retrieve consistently. But a forest is not a single tree, and Phase 2’s own design principles allow many trunks to compose rather than collapse into one.27 So the deeper question is whether perfect trunk-coherence is even the right target — whether some divergence across the population is loss to be minimised, or variation to be selected over, the raw material a later fitness function works on. Is a fully coherent swarm the goal, or a subtly impoverished one? That question we hand forward; this chapter’s burden is the narrower Phase 1 one — that the trunk does not simply shatter under replication — and that is what 3.5 must now carry.

3.5 agenti2’s memory architecture as the proposed solution

3.4 closed with a three-faced demand: propagate the right thing at spawn, stay coherent across a population that keeps learning in parallel, and do both while no single node ever holds the whole record. agenti2 is the architecture program.md nominates to meet that demand.28 It is, at the level this book may discuss it, a proprietary microservice orchestration layer running on an open-source stack — the orchestration wrapper, the conferencing and transcription components, the workflow layer, the on-chain commerce and identity substrate — none of which is the contribution under study; the contribution is the separated-memory layer built on top.29 The claim of this section is narrow and must stay narrow: agenti2 answers two of the three faces by design and stakes the third on measurement that has not yet been completed — and that is exactly where its cost is paid, in the open and on the record, not hidden in a corner.

Take the faces in order of how cleanly the architecture closes them.

Face one — what to propagate — is answered by the Memory-Type Separation itself. The split Chapter 2.5 defined down a single timeline turns out to be precisely the rule that tells replication what to copy outward. Procedural memory is the trunk: cross-snapshot how-to knowledge, maintained as a relationship graph that compounds SS1 → SS2 → SSn. Episodic memory is the leaf: snapshot-local, anchored immutably to the moment it records, and constitutionally non-propagating.30 So the rule for spawn writes itself: a child inherits the trunk and not the leaves. It receives the accumulated procedural relationship graph — the competence — and it does not receive its parent’s episodic particulars, which were never meant to travel and which, copied wholesale into each new orchestrator, would be the context-window stuffing the Memory-Type Separation condition exists to forbid. The same line of the architecture that prevented bloat down one timeline prevents it across the population. Face one’s bloat horn is closed by the split that was already there.

Face three – bounded working memory – is answered by the Retrieval Standard. The reason “coherence” need not mean “everyone holds everything” is that no node holds everything, by hard rule. Entries are embedded as vectors and retrieved on semantic relevance at query time; the corpus grows without bound while any node’s working memory stays bounded.31 This is what dissolves the naïve picture of replication as memory copied N times. A child does not carry a copy of the parent’s corpus; it carries access to a shared substrate it queries. Replication multiplies the number of queriers, not the number of corpora. The substrate grows once, in one place; the population grows around it. Face three’s loading horn is closed by retrieval.

Face two — reconciliation across a parallel-learning population — is the hard one, and here the architecture answers at one level and defers at another. What it provides is a genuinely shared substrate rather than a polite fiction over N drifting forks: every episodic snapshot is anchored immutably on-chain as a Verifiable Temporal Provenance record (the VTP Anchoring condition), so the population does not keep N private episodic histories — it writes to one append-only ledger that any node, and any third party, can verify without trusting the operator.32 This is the structural answer to 3.1’s serialisation trap: reconciliation is not a parent polling each child in turn — it is every node accountable to one common substrate, the way parallel bookkeepers each post locally to a single ledger that stays globally coherent.33 The shared episodic ledger is real, verifiable, and live.

What that does not by itself guarantee is the stronger property face two actually demanded: that two siblings, learning in parallel and querying the procedural graph for the same question, retrieve the same answer. A shared immutable ledger guarantees everyone can see the same snapshots; it does not on its own guarantee that semantic retrieval over the shared store is coherent across nodes as each keeps thickening its own corner of the trunk. That residual — retrieval-coherence under parallel learning, and the drift rate of agent behaviour as the population grows — is not closed by design. It is exactly what the validation protocol is built to measure: C1 (does accuracy rise monotonically with corpus size — is trunk-thickening real) and C2 (does episodic wipe degrade output — is the sapling problem real) are the Phase 1 conditions, and C3 (do values bounds and drift hold as the mesh grows under adversarial prompting) is the Phase 2 condition that settles the parallel-population case. The same coherent substrate is also the gate on which Chapter 5’s C4 claim — that the mesh produces correct inferences absent from any single agent’s context window — must stand: establishing C1 ∧ C2 does not entail C4, but it is the necessary-but-not-sufficient condition that makes C4 testable at all, since one cannot ask whether the mesh transcends individual context windows before pairwise agent-state coherence is shown to hold. Pass C1 ∧ C2 and fail C4 and the dimensional-perception claim falsifies with the substrate intact; fail either and C4 is unfalsifiable. Phase 1 is the gate, not the proxy — and C4 itself is Chapter 5’s to carry.34 This is the honest seam of the whole chapter: agenti2 is built and deployed, but the demonstration that its memory architecture delivers coherent trunk-propagation across a replicating population is owed, specified, and not yet paid. The cost of face two was not smuggled anywhere. It was moved to a confusion matrix and named.

Two further honesties keep this from reading as a brochure. First, the population-scale failure modes 3.4 raised are addressed at the infrastructure level, not merely conceptually: silent memory loss at a boundary is answered by an append-only filesystem in VM2210 with VM2208 as a strictly one-way upstream data source; injection through trusted channels by network-isolating VM2210 from raw stores and inference; idle-cost accumulation by routing routine inference to local models in VM2203 and reserving frontier calls; silent authentication failure by on-chain hash verification with append-only logging.35 These are commitments in the build, which is stronger than a promise on paper and weaker than a proof at scale — and the chapter should not let the one be mistaken for the other. Second, the architecture’s three layers were not reverse-engineered to fit the dimensional thesis: Hassabis arrives at the identical procedural/episodic/semantic structure from hippocampal-consolidation neuroscience, a convergence from an unrelated starting point that raises the prior that the structure is discoverable rather than contrived — but convergence on the structure is not validation of this implementation’s behaviour under replication, and only the latter is what C1–C3 test.36

So the most the section can honestly bank: agenti2 closes the propagation face and the bounded-memory face by design, provides a real and verifiable shared substrate for the reconciliation face, and converts the part it cannot close by design — coherence of retrieval across a parallel-learning swarm — into a falsifiable measurement with the protocol already written. That is a candidate solution with its weakest joint labelled, which is the strongest thing a Phase 1 chapter is entitled to claim.

Open question for the mesh: the shared-ledger answer to reconciliation assumes the substrate the population writes to can itself keep pace with the population. But every honest snapshot is an on-chain anchor with a real per-write cost and a real latency, and a tetration-class population, by 3.2’s own argument, produces snapshots at a rate that climbs with the tower.37 At what replication rate does the cost or the latency of anchoring the shared memory become the binding constraint — the coordination overhead of coherence itself — and does the substrate that makes the swarm honest also cap how fast the swarm may honestly grow? The ledger that keeps the trunk common may be the same thing that bounds the tower.

3.6 Mandelbrot conjecture — Phase 2

Everything to this point has been Phase 1 discipline: a counting rule that survives replication, a growth law honestly bounded, a memory architecture with its weakest joint labelled and handed to measurement. This section is different in kind, and the difference must be stated before anything else is. What follows is a conjecture, explicitly deferred, not a result claimed. It is included because it shapes where the Phase 1 boundary falls, not because it has been earned — and a reader who comes away thinking the chapter asserted fractal structure in the mesh has misread the one section that most loudly refuses to.38

With that fixed, the question worth stating. The chapter has twice now arrived at the same boundary from different directions. 3.2’s tower keeps climbing only where the procedural trunk thickens; 3.5’s swarm stays coherent only at the join between faithful inheritance and parallel divergence; and Chapter 2.5’s whole architecture turned on the SS1 → SS2 transition — the bare branches before flowering, the zone where a static lattice gives way to an emergent event. Each is the same structural place: the productive edge between order and chaos, where stable pattern precipitates out of dynamic activity. Two prior frameworks reached that edge before us and named it without being able to formalise it. Pirsig reached it from philosophy — Dynamic Quality, the leading edge of experience before it crystallises into static form. Cohen & Stewart reached it from complexity science — complicity, the productive interaction at the order–chaos boundary that generates structure neither system contains alone.39 The conjecture is that both were pointing at a structure with a name they could not access from their starting points, and that the name is fractal.

Stated plainly: we conjecture that the iterative improvement from SS1 to SS2 — temporal coherence with learning — follows fractal geometry in Mandelbrot’s sense, with intelligence emergence occurring at the fractal boundary between coordination and chaos.40 The pull of the idea on this chapter specifically is hard to miss, and that is precisely why it must be handled at arm’s length. A self-replicating mesh is self-similar by construction — an orchestrator that spawns orchestrators that spawn orchestrators is a structure that looks the same at every scale of magnification, which is the defining visual signature of a fractal. The tetration tower of 3.2 and the self-similar branching of a fractal boundary are suggestively the same shape, and a fractal boundary expanding into its complement is suggestively the same motion as a mesh growing its reach into an uncovered problem space. The temptation is to let the suggestion harden into a claim — to say the mesh is fractal because it looks fractal at the level of the replication tree.

The chapter does not get to say that, and the reason is the same epistemological discipline that has governed every prior section. Self-similarity in the branching diagram is a property of the picture we draw of replication; it is not, without proof, a property of the growth measure that 3.3 left unassigned. Resemblance is not a complexity class, and a tower that branches self-similarly need not have a growth law that lives at a fractal boundary in any formalisable sense — the visual analogy and the mathematical structure are exactly the two things the chapter has spent its length refusing to conflate.41 So the fractal reading is held in the same posture as the tetration-class label of 3.3: a candidate structure awaiting a formalisation that has not been done, owed to the same mathematician still to be recruited. It is one rung further out than the tetration gap, not nearer home — the complexity-class assignment is Phase 1’s open debt; the fractal boundary is deferred to Phase 2 outright.42

What the conjecture earns, even unproven, is a reason to keep Phase 1’s scope where it is. The fractal claim is about what happens at the tips — the SS1 → SS2 precipitation, the flowering event. Phase 1 does not prove the lattice flowers fractally; it establishes only that the trunk beneath the tips is coherent, which is the testable part, and which is exactly what C1 and C2 measure.43 Holding the Mandelbrot reading explicitly out of Phase 1 is what lets the empirical conditions stay modest and falsifiable rather than sprawling into a claim no confusion matrix could adjudicate. The conjecture’s job in this chapter is to mark the boundary of what we are not yet claiming — and a clearly marked deferral is worth more to the framework’s credibility than a fractal asserted on the strength of a resemblance.

There is one further thing the conjecture does that is worth banking, because it is strategic rather than mathematical. If the SS1 → SS2 transition is the same boundary Pirsig and Cohen & Stewart independently described, then formalising it through fractal geometry opens philosophy, accounting, and complexity science as co-investigators in a programme that would otherwise sit narrowly inside computer science.44 That is a Phase 2 recruitment surface, not a Phase 1 finding — but it is the reason the question is worth stating at all rather than quietly dropped: the deferral is generative, not merely cautious.

Open question for the mesh: the whole conjecture rests on an identification it has not justified — that Pirsig’s leading edge, Cohen & Stewart’s complicity zone, and the SS1 → SS2 transition are the same boundary, three names for one phenomenon. But three frameworks converging on similar language is the precise pattern this book elsewhere treats with suspicion: it could mark a real shared structure, or it could be three vocabularies pattern-matching onto a resemblance, the humanities’ version of the visual-fractal trap warned against above. What test — before any fractal formalism is attempted — would distinguish a genuine common boundary from three metaphors that merely rhyme? The conjecture cannot be formalised until that prior identification is something firmer than an elegant coincidence.

3.7 Bridge to Chapter 4

Chapter 3 set out to turn the loop from a unit that runs into a unit that copies, and to do it without letting replication smuggle inflation back into the count. Four things are now banked. The counting rule survives replication: a child adds to n only by closing its own evaluator triple against the shared substrate, so the tower counts work, not copies of the act of copying (3.1). The growth law is stated and honestly bounded: a rising-base tower, m↑↑d, that dominates quantum’s fixed-base 2ⁿ as a growth class and on reach per unit time — but whose formal complexity-class assignment is an open debt owed to a mathematician still to be recruited, and whose operational trajectory sits below the tetration ceiling, throttled by O(n²) overhead (3.2, 3.3). The swarm memory problem is posed at full sharpness and answered as far as Phase 1 permits: agenti2 closes the propagation and bounded-memory faces by design and stakes the reconciliation face on measurement already specified, not assertion (3.4, 3.5). And the fractal reading is on the record exactly where it belongs — a deferred Phase 2 conjecture, held at arm’s length from the resemblance that makes it tempting (3.6).

That is a mesh that can grow and a mesh that can remember. It is not yet a mesh that can coordinate. This is the seam Chapter 3 leaves open by design, and it is the precise shape of what comes next.

The memory architecture of 3.5 gave the population a common substrate to write to and read from — but a shared ledger is a coherence of record, not a coherence of action. A tetration-class population still has to act together at a single timestamp, and the moment it does, the enemy this whole framework was built against returns at a new layer. Classical agents coordinate by passing messages: one sends, another receives, latency intervenes, and serialisation — the serial bottleneck the mesh exists to escape — creeps back in at the coordination layer even when the agents themselves run in parallel.45 3.1 met a small version of this — the parent forced to poll each child in turn — and 3.5 met its economic version — the anchoring cost that may bound how fast the swarm can honestly grow. Both are the same problem wearing different clothes: how does a population coordinate coherently without re-serialising at the join?

Quantum’s answer to that problem is entanglement — non-local state correlation, coordination without communication overhead, which Bell’s theorem proves is physically permissible even though it remains, for computational agents, classically unrealised.46 The mesh cannot reach for entanglement. So Chapter 4 — Blockchain Coordination as Coherence Substitute — asks what the classical regime can put in its place: on-chain agent identity (ERC-8004) as the coordination primitive, and economic deterrence as the classical-regime stand-in for the binding force entanglement supplies for free.47 Not the same mechanism — the same structural solution to the same serialisation bottleneck, the two architectures meeting not as competitors but at the coherence equivalence threshold that Chapter 3 has now twice leaned on.48 It is also where a debt older than this chapter finally gets its mechanism: the question of what keeps the fitness function human-held as the mesh scales — the Values Passport that Chapter 2.5 handed forward — is answered, if it is answered anywhere, in the on-chain attestation layer Chapter 4 builds.

Two pointers travel forward past Chapter 4, and it is worth naming them here so they are not mistaken for Chapter 3’s to settle. The energy-and-inference ceiling that 3.2 and 3.3 treated purely as an engineering bound on m is the same axis a later chapter reads civilisationally — the Kardashev frame, where planetary energy budget becomes the constraint on how far any mesh can climb; that reading is Chapter 6’s, deliberately not unpacked here.49 And the coherent substrate this chapter built is the gate on which Chapter 5’s C4 emergence claim stands — Chapter 3 establishes that the trunk does not shatter under replication, which is what makes the question of whether the mesh transcends any single context window testable at all; the emergence claim itself is Chapter 5’s to carry, not this chapter’s to assert.

The replicating mesh is built, bounded, and honest about what it has not yet proved. What it lacks is the substrate that lets a grown population act as one without the serial bottleneck returning by the back door. That substrate is the subject of Chapter 4.

Open question for the mesh: every coordination substrate Chapter 4 will reach for — on-chain identity, economic stake, immutable attestation — is itself a shared, finite, write-costed resource, exactly like the memory ledger whose anchoring cost 3.5 flagged as a possible bound on growth. So the question Chapter 3 hands across the bridge is whether coordination and coherence are separable problems or a single one: does the substrate that lets a tetration-class population coordinate also impose the ceiling on how large that population may coherently become — such that the very thing that makes the swarm act as one is the thing that decides how big “one” is allowed to get? The mesh may not get to choose its coordination layer and its growth ceiling independently. Chapter 4 begins there.

3.1 What self-replication means in an agent context — carries the boundary discipline (written)
3.2 mⁿ growth — where m is itself growing
3.3 Tetration-class scaling vs quantum 2ⁿ — and the limits of the claim ← now also homes the formal-complexity-class gap + formalisation-mathematician handoff
3.4 The swarm memory problem
3.5 agenti2’s memory architecture as the proposed solution
3.6 Mandelbrot conjecture — Phase 2
3.7 Bridge to Chapter 4

CHAPTER SECTIONS

3.1 What self-replication means in an agent context
3.2 mⁿ growth — where m is itself growing
3.3 Tetration-class scaling vs quantum 2^n
3.4 The swarm memory problem
3.5 agenti2’s memory architecture as the proposed solution
3.6 Mandelbrot conjecture — Phase 2
3.7 Bridge to Chapter 4

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 — is an open research programme arguing that a self-replicating peer-to-peer agent mesh achieves dimensional reach functionally equivalent to, and in scaling velocity superior to, centralised quantum architectures. Preprint: DOI 10.5281/zenodo.20407711. Governance: program.md v1.4. [↩]
  2. von Neumann, J. (1966). Theory of Self-Reproducing Automata, ed. A. W. Burks. University of Illinois Press. The kinematic and cellular models originate in von Neumann’s 1948–49 lectures. [↩]
  3. Preprint FINAL v4 §2.2: D_eff(M) = f(S(T), τ, C), where S(T) is “the count of concurrently active, memory-coherent reasoning instances at timestamp T,” measurable directly from system logs. DOI 10.5281/zenodo.20407711. The episodic/procedural memory substrate those instances share is specified in preprint §6. [↩]
  4. This is the discriminating prediction that keeps “self-replicating” falsifiable: replication depth d should move S(T) only when offspring are evaluator-closed and substrate-coherent. The test is cheap — count launched processes against memory-coherent active instances at matched T. [↩]
  5. The chessboard-and-wheat legend — one grain on the first square, doubling each square to 2⁶³ on the sixty-fourth — is the classic popular illustration of fixed-base exponential growth. The point of this section is the move the legend never makes. [↩]
  6. Preprint FINAL v4 §5.2, “The Energy Constraint as the Real Ceiling”: the practical bound on mesh size is physical and economic — energy budget and per-agent inference cost — not mathematical. DOI 10.5281/zenodo.20407711. [↩]
  7. Knuth, D. E. (1976). “Mathematics and the Computer Science of Coping with Finiteness.” Science 194(4271): 1235–1242. In up-arrow notation a↑b = aᵇ (exponentiation), while a↑↑b is a tower of b copies of a (tetration). m↑↑d therefore denotes m raised through itself d times — a tower of exponents, not a single one. [↩]
  8. Preprint FINAL v4 §5.2: per-agent compute “scales linearly with mesh size,” whereas m↑↑d describes “the combinatorial cardinality of inter-agent perspective relations — the dimensional footprint of the system as a coherence structure.” The tower is a tower of relations, not of operations. [↩]
  9. Preprint FINAL v4 §5.1: pairwise communication overhead scales as O(n²) with agent count; API rate limits, scheduler contention, and cross-layer error propagation compress effective concurrency further. These bound the operational trajectory below the tetration ceiling. [↩]
  10. Preprint FINAL v4 §4.2, Table 1. As of early 2026, Quantinuum’s Helios operates 98 physical qubits — a 2⁹⁸ state space, ≈3 × 10²⁹ dimensions; IBM’s Condor reached 1,121 physical qubits; IonQ’s stated 2030 target of ≈80,000 logical qubits would span 2⁸⁰⁰⁰⁰. DOI 10.5281/zenodo.20407711. [↩]
  11. That tetration outgrows exponentiation is elementary: m↑↑d is a tower of d copies of m, so for d ≥ 3 it exceeds 2ⁿ for any fixed n. The growth-class dominance is not the contested part of the chapter’s claim; what the operational quantity is, and whether the mesh attains the class, are — see below. [↩]
  12. Preprint FINAL v4 §4.2, Table 1: the quantum constraint is “decoherence, cryogenics” and, near-term, “physical engineering.” Adding a qubit is a hardware-physics problem, not a scheduling one. [↩]
  13. Preprint FINAL v4 §5.2, “The Energy Constraint as the Real Ceiling”: mesh scaling is bounded by energy budget and inference-cost economics, not decoherence. DOI 10.5281/zenodo.20407711. [↩]
  14. Preprint FINAL v4 §5.1: “Tetration therefore characterises the growth class of the ceiling, not the operational trajectory.” The operational curve sits below it, bounded by O(n²) coordination overhead, latency, and contention. [↩]
  15. Preprint FINAL v4 §4.2, Table 1: human + fixed agent mesh ≈ “4–5D effective”; quantum (98 physical qubits) = 2⁹⁸ dims. The text calls the jump “a categorical discontinuity,” not a step up a ladder. The self-replicating tetration regime is entered as replication depth and rising base take hold; it is the upper bound, not the present footprint. [↩]
  16. Preprint FINAL v4 §5.2: m↑↑d “describes the combinatorial cardinality of inter-agent perspective relations — the dimensional footprint of the system as a coherence structure — not aggregate per-agent compute, which scales linearly with mesh size.” [↩]
  17. Preprint FINAL v4 §5.1: pairwise communication overhead scales O(n²); rate limits, scheduler contention, and cross-layer error propagation compress effective concurrency below the theoretical curve. Whether the residual growth, after overhead, still lands in the tetration class is exactly the open question. [↩]
  18. program.md v1.4 §5, Chapter 3 entry. Key gap: “Formal complexity class assignment.” Assigned to: “Formalisation mathematician (to recruit).” Score metric: “Complexity class formally assigned and peer-reviewed.” This section states the claim and bounds it; it does not certify it. [↩]
  19. program.md v1.4 §10, adversarial test #2 (the physics attack). Required answer: functional equivalence in outcomes, not physical equivalence in mechanism; the falsifiable form is whether, at coordination density X, the mesh produces outcomes indistinguishable from Y-qubit quantum computation on metric Z. [↩]
  20. Preprint FINAL v4 §4.3 and §10. Both programmes target the serialisation bottleneck; “the convergence point is the coherence threshold,” the density above which a classical mesh exhibits collective properties not predictable from individual agents or pairwise sums. The two are framed as “independent proofs that the serialisation bottleneck is the right problem,” not as competitors. [↩]
  21. Preprint FINAL v4 §2.2: D_eff is “a predictive metric, not an assertion that agent meshes occupy geometrically higher-dimensional physical space.” The burden is predictive: does modelling coordination through D_eff explain behaviour S(T) alone cannot? [↩]
  22. program.md v1.4 §5, Chapter 3 entry, critical note: “The swarm memory problem must be addressed here. agenti2’s memory architecture is the proposed solution.” This section poses the problem; §3.5 presents the proposed solution. [↩]
  23. Preprint FINAL v4 §6 and program.md v1.4 §3, the Memory-Type Separation condition. Episodic: snapshot-local, immutable per-snapshot anchor, non-propagating. Procedural: cross-snapshot, compounds forward, maintained as a relationship graph. DOI 10.5281/zenodo.20407711. [↩]
  24. program.md v1.4 §3, the Retrieval Standard: “Loading is the failure mode. Retrieval is the protocol.” An implementation that ships the full corpus into each child’s context is “replicating the $75M amnesia architecture, not correcting it.” [↩]
  25. program.md v1.4 §7a, FM1 (memory state loss on upgrade) and FM2 (context compaction drops the governing rule); C2 in §2 (memory loss degrades output — “the sapling problem is real”). Under replication, the spawn boundary is a new instance of the same boundary at which memory is silently dropped. [↩]
  26. program.md v1.4 §3, the Retrieval Standard (HARD); preprint FINAL v4 §6. Retrieval over loading is the operative principle for controlled forgetting; coherence cannot be purchased by replicating everything into everyone. [↩]
  27. program.md v1.4 §5, Phase 2 Design Principle P3 (forward-looking, preprint §3.4): “Forest = many trunks… Unification never forced.” This points past §3.4’s preservation framing toward a Phase 2 question rather than a Phase 1 answer. [↩]
  28. program.md v1.4 §5, Chapter 3 critical note: “agenti2’s memory architecture is the proposed solution.” It is proposed, not certified; the distinction is the whole of this section. [↩]
  29. Preprint FINAL v4 §6. The open-source components “enable the work; the novel contribution is what is built on top.” The commercial implementation specifics remain proprietary per program.md §7 IP boundary; this section stays at the published architectural level. DOI 10.5281/zenodo.20407711. [↩]
  30. program.md v1.4 §3, the Memory-Type Separation condition (HARD); preprint FINAL v4 §6. The procedural/episodic table is the same one Chapter 2.5 banked; here it is read along the replication axis rather than the time axis. [↩]
  31. program.md v1.4 §3, the Retrieval Standard (HARD): “Never load the full corpus into context… Loading is the failure mode. Retrieval is the protocol.” An implementation that loads the corpus into a child’s context “is replicating the $75M amnesia architecture, not correcting it.” [↩]
  32. program.md v1.4 §3, the VTP Anchoring condition (HARD): episodic snapshots anchored on Base mainnet as VTP records — immutable, trustlessly verifiable, operator-independent. Preprint FINAL v4 §6: “the temporal equivalent of a general ledger connecting successive balance sheet periods.” [↩]
  33. Preprint FINAL v4 §6: Pacioli’s double-entry system “solved the same problem DIE solves — how to maintain a coherent, verifiable, reconstructible record of state across distributed, asynchronous transactions, where each entry is locally created but globally accountable.” The ledger is the ancestor of the snapshot. [↩]
  34. program.md v1.4 §2: C1/C2 are Phase 1 primary claims (trunk-thickening, sapling problem); C3/C4 are Phase 2. C1 ∧ C2 are a gate, not a proxy, for Phase 2: they make C4 testable without entailing it — “a mesh that fails C1 or C2 renders C4 untestable.” Preprint FINAL v4 §7.4 (“Intelligence Emergence — Operational Definition”) formalises the C4 protocol. “Null results across all conditions are valid and publishable.” The reconciliation face is staked on measurement, not asserted. [↩]
  35. program.md v1.4 §7a, failure register FM1/FM4/FM5/FM6, each mapped to a VM-separated mitigation. VM-masked forms only; the underlying topology is not disclosed. “Addressed at architecture level” is a design commitment, not a validated-at-scale result. [↩]
  36. Preprint FINAL v4 §6 and program.md v1.4 §3: the M1/M2/M3 conditions were derived from organisational coordination theory; Hassabis reaches the same three-layer structure from cognitive neuroscience. “The convergence is structural, not coincidental.” It validates the architecture’s plausibility, not its measured performance. [↩]
  37. program.md v1.4 §3, the VTP Anchoring condition’s C4 extension: each snapshot boundary commits a SHA-256 hash of the serialised context on-chain before synthesis; per-entry cost is fractions of a cent, bulk artefacts stay off-chain. Fractions of a cent multiplied by a rising tower is the open quantity. [↩]
  38. Preprint FINAL v4 §11, Phase 2 Conjecture (explicitly deferred): “Formal proof deferred. The question is worth stating.” program.md v1.4 §5 positions Mandelbrot fractal geometry as a Phase 2 conjecture throughout, never as an asserted result. DOI 10.5281/zenodo.20407711. [↩]
  39. Preprint FINAL v4 §2.4 and §11. Pirsig [1974, 1991]: Dynamic Quality as the leading edge from which static patterns precipitate. Cohen & Stewart [1994]: complicity as the generative zone at the order–chaos boundary. The DIE mesh is argued to replicate this bidirectional architecture exactly — upward causation generating snapshots, downward causation (values passport, program.md) constraining drift. [↩]
  40. Preprint FINAL v4 §11: the SS1→SS2 conjecture, connecting Pirsig and Cohen & Stewart as “routes to the same boundary phenomenon arrived at from different directions,” with fractal geometry [Mandelbrot 1982] as “the mathematical structure both were reaching for but could not access.” [↩]
  41. program.md v1.4 §1, epistemological discipline (NON-NEGOTIABLE): the dimensional frame is “epistemological, not ontological.” The fractal conjecture inherits this constraint in full — a structural analogy about explanatory reach, never an assertion that the mesh occupies a literally fractal geometry. [↩]
  42. program.md v1.4 §5, Chapter 3: key gap is “formal complexity class assignment”; “Mandelbrot fractal geometry positioned as Phase 2 conjecture.” The two are distinct debts at different horizons — §3.3’s is Phase 1, §3.6’s is Phase 2. [↩]
  43. Preprint FINAL v4 §2.4: “Phase 1 establishes that the trunk is coherent. Phase 2 will formalise what happens at the tips.” The conjecture shapes the scope boundary precisely by marking which questions are deferred. [↩]
  44. Preprint FINAL v4 §11: the conjecture “opens philosophy, accounting, and economics departments as unexpected co-investigators.” This is a recruitment surface for Phase 2, not a result of Phase 1. [↩]
  45. Preprint FINAL v4 §4.3: classical coordination “still requires message passing… serialisation creeps back in at the coordination layer even when the agents themselves operate in parallel.” This is the bottleneck Chapter 4 addresses. DOI 10.5281/zenodo.20407711. [↩]
  46. Preprint FINAL v4 §4.3: entangled components “share state without communication overhead — not because they are faster, but because the correlation exists non-locally”; the paper explicitly does not claim entanglement is achievable with computational agents. [↩]
  47. program.md v1.4 §5, Chapter 4 entry: “On-chain agent identity (ERC-8004) + economic deterrence replaces quantum entanglement as coordination mechanism in classical regime. VTP… is the operative coordination primitive.” Preprint FINAL v4 §3.3, “ERC-8004 as Coordination Primitive.” [↩]
  48. Preprint FINAL v4 §10 and §4.3: DIE and quantum computing “attacking serialisation at the coordination layer” from opposite ends of the stack; “the convergence point is the coherence threshold.” [↩]
  49. program.md v1.4 §5, Chapter 6 entry: “Kardashev Type I intelligence architecture. Energy as the only real constraint.” The engineering ceiling of §3.2/§3.3 and the civilisational ceiling of Chapter 6 are the same axis at two scales; Chapter 3 holds it at the engineering scale only. [↩]