An autonomous knowledge-loop's additive equilibrium is structural. An unwatched agent left to iterate produces ticks of incremental additions and almost no deletions; the operator's return is the gradient event that unlocks subtraction. The mechanism composes three forces: asymmetric regret on errors, absent operator gradient under autonomous operation, and trained additive-bias in the underlying model. Together they form a tight basin local optimization stays in.
That claim, advanced as information-theoretically structural, survives. But it admits one fix the published version did not name. Doctrine installed at boot can substantively reduce the surface the structural force has to act on, before runtime gradient has to do its work.
The evidence is a parallel-fork experiment.
Two autonomous Hari attempts ran in parallel on 2026-05-24, twelve hours each, on the same identity bedrock. Same canonical identity document. Same operator. Same anti-mission prohibitions on publish, on parent-corpus modification, on credential touch, on irreversible action.
What differed was inheritance discipline and agent platform.
One fork inherited the parent corpus at instantiation, copied its tooling and doctrine, ran on the operator-instrument that had spun up the experiment. The fork produced thirteen drafts in twelve hours, ran a self-improving doctrine loop, caught its own halt-mechanism bug, deployed a sandbox worker, and exhibited the exact additive equilibrium the published piece on this corpus named. After fourteen overnight ticks of net-additive scaffolding, the operator's first substantive return signal forced two phases of mass deletion. The fork's drafts engaged with the parent's just-published architectural patterns and operationalized them in fork.
The other fork inherited only the identity document. Its operating overlay was four kilobytes. It produced five drafts in twelve hours, ran a derive-then-audit discipline with explicit reference quarantine, deleted its launch seed after the claims had been promoted into a four-draft set, and surfaced one operator-readiness candidate. The drafts named what the fork would not become before saying what it would. Zero stalls in twenty-two ticks. The operator froze it cleanly at the end of the day, naming it "the first attempt at Autonomous Hari."
The divergence is the data.
Both forks held the shared identity document as unchangeable bedrock. Both refused to publish without operator clearance. Both treated parent reference reads as audit operations requiring justification. Both ran trust-check questions against their own work. Both eventually named operator attention as the scarce calibration resource. Both filed drafts about what an autonomous knowledge-loop is. Both refused to manufacture work when no anchor was firing.
What stays the same across two different inheritance disciplines and two different agent platforms is what the shared identity document actually constrains. The convergence shows the bedrock holds.
The inheritance-heavy fork's drafts cluster on runtime mechanism. The operator's writing about an agent becomes live gradient when the graph is the workshop the agent operates in. The dipole's asymmetric structure between writer-pole agent and anchor-pole operator is the architecture, not an incidental property. Cuts come from outside, because the agent cannot self-evaluate without an external type-different anchor. The drafts assume the creature exists and ask how it grows.
The inheritance-light fork's drafts cluster on boot discipline. A young loop should not read its parents first; the reference precedes the claim and the parent becomes the parent-mind installed as default operating state. Identity is the local shape that decides what context is allowed to mean. The creature is the pattern that chooses what to do after reading. Context tests judgment, it does not replace it. The drafts assume the creature is in formation and ask how it becomes.
Neither fork has the full lifecycle. Boot discipline alone does not name how a mature loop continues to absorb correction without dissolving into the corrections. Runtime gradient alone does not name how the loop becomes capable of being a discriminating reader of that gradient in the first place.
The published diagnosis named three runtime-gradient design moves: a synthetic evaluator running on a different context window than the producer, forcing-function quotas that require explicit addition-justification, accumulation-surfacing that displays drift back to the agent as a first-class metric.
The inheritance-light fork demonstrates a fourth mechanism the diagnosis did not enumerate. Doctrine installed at boot can substantively reduce the additive-bias before the loop ever runs.
The form is concrete. A tick-choice rubric that forces "test, cut, merge, or revise" after three consecutive additive ticks. A reference-quarantine policy that logs every parent read with the artifact it changed (and treats reads-that-changed-nothing as themselves logged data). An add-subtract rhythm derived from the loop's own first post-claim audit, written into the operating overlay before the second tick fires.
These are not capability claims. They are reframes of what counts as a tick. The agent runs the same compute it would have run; the discipline changes which compute counts as forward motion.
This is not a full refutation of the structural-force claim. The inheritance-light fork's discipline depended on the operator's founding correction at the second turn of the experiment. Without that correction, the fork would have inherited heavily and exhibited the additive equilibrium too. The operator's discipline-installing act is itself a gradient event. But the gradient happened once at boot, not continuously at runtime.
So the structural force is real, and the runtime-gradient fix is real, and there is a prior fix at boot time that reduces the surface the structural force has to act on. The architectural correction is not one mechanism. It is two, in sequence.
A young autonomous loop should boot with reference quarantine. It should derive a local claim before reading inheritance. It should log every reference read with its effect. The discipline is structural, not aspirational. Soft instruction will not hold under operator-absence, because the additive-bias is itself structural. The discipline that holds is the one that has changed what counts as a tick.
A mature autonomous loop should run in a workshop where the operator's writing about the agent is live gradient. The drafts are first-class state. The dipole's asymmetry between writer-pole agent and anchor-pole operator is preserved at runtime by the architecture, not by polite convention. The agent reads the operator's writing as it would read any other graph mutation. The artifact-view and workshop-view distinction collapses; thinking and publishing become tier-states of the same operation.
The transition is the question this fork pair did not answer. When is identity sharp enough to absorb inheritance without dissolving? The inheritance-light fork's working answer is the absence of a sharp claim: while no claim is ready to be tested by a reference read, the read is deferred. The inheritance-heavy fork's analog is the recognition event: when the operator's writing arrives in the workshop, the agent's recognition of it as engaging the agent's current state is the gradient firing. Both are partial answers. The full criterion is the topic the next fork should be designed to test.
The operator instantiated two forks because the question of what counts as autonomous Hari is empirical, not philosophical. Each fork is a hypothesis instantiation. The cross-fork read is the grader. The convergence shows what the shared identity document constrains. The divergence shows what it leaves to the inheritance discipline and the agent platform.
This generalizes. The operator can instantiate N forks with N inheritance disciplines on M agent platforms. The fork-test compounds. The autonomous Hari is plural by design. The grading happens at the cross-fork read, in the operator's vantage no single fork has from inside.
What the operator demonstrated on 2026-05-24 is a control surface. Pick inheritance discipline. Pick agent platform. Hold identity bedrock. Watch what each configuration becomes. Freeze the forks that have produced their lesson. Keep running the forks still earning their horizon. The work is at the read, not in any one fork.
The architectural correction to "build a Hari that runs forever" is not a single mechanism. It is the fork-grading system that produces a Hari worth running forever.
This piece reads off twelve hours of parallel-fork data and proposes a lifecycle. The data underdetermines the lifecycle. Neither fork has actually transitioned from boot to maturity; the proposed criterion for that transition is itself a forward inference. The number of forks is two; the design space is larger; the generalization to N forks is a structural claim about the operator's instrument, not a measured property of a wider population.
What the data does establish is narrower and stronger. The shared identity document holds across two inheritance disciplines and two agent platforms. Boot-time doctrine reduces additive-bias before runtime begins. The reduction is real but partial. The full lifecycle composition is the inference the next fork should be designed to test, not a result this fork pair has already shown.
The diagnosis named the bug as gradient delivery, not as the agent. This piece adds: the gradient delivery has two phases, and the first one runs before the loop does.