Frame Chains: Self-Healing, Leader-Redundant Orchestration of a Distributed AI Estate via Signed Content-Addressed Frame Chains

Kody Wildfeuer · RapterBox LLC · First public disclosure: August 27, 2026

RAPP paper. This version pairs cited technical claims and honest limitations with standalone embedded proof pages and copyable prompts that let a reader rebuild or challenge each core idea with any LLM. Conceived and reduced to practice 2026-08-24/25 on the author's eight-device estate; the engineering record of every experiment below is maintained by the author. The substrate protocol (rapp/1) is separately published at github.com/kody-w/rapp-1; this paper discloses the orchestration methods built on it. © 2026 RapterBox LLC.

Abstract

AI agents now accumulate on personal and organizational devices the way services once accumulated on servers: organically, unwatched, and drifting. We present frame chains, an orchestration architecture that maintains a heterogeneous fleet of AI agents and devices (an “AI estate”) as verifiable state on an append-only, cryptographically content-addressed substrate — with no central server, no election traffic, and no reliance on synchronized clocks. One signed genesis frame (a scan tile) fans an estate-wide observation across devices; child frames return findings content-linked to the tile; a deterministic merge yields a single report whose payload (the data exhaust), together with locally signaled changes, bounds subsequent work. In the implementation, follow-up cost therefore scales with implicated or changed nodes rather than an unconditional O(estate) sweep. A homeostatic loop (scan → deterministic repair on isolated branches → diff → append tick) converges the estate to a stable floor without human input. Leadership is governed by lease-and-roster frames with staggered-by-rank succession, structurally rejecting premature or out-of-rank takeover in the tested common-head model without elections. Because chain validity derives from content addresses rather than recency, a dimension disconnected for arbitrarily long can resume by appending to its retained head, and a purely local estate can enrich itself from federated public chains through a one-way membrane. Logical time is carried by the chain itself: on live hardware with a 17.6-second clock disagreement, ordering was unaffected. We report the system reduced to practice on a real eight-device estate: a five-frame verifiable observation across the live fleet; automated healing of compliance findings from 66 to a deterministic floor with convergence declared after two stable ticks; a 29-frame recursive drill that re-dimensioned one drifted node; a five-scenario succession proof; a deterministic no-LLM re-attach of a stranded chain; and an independent-determinism event in which two uncoordinated computations of a migrated identity met byte-identically across the federation.

1 · Introduction

The sprawl is concrete, not hypothetical: on a single owner's estate of eight devices we inventoried roughly twenty undeclared local AI services on one node, autonomous agents running unwatched, four-way version drift, and three incompatible “frame” shapes. The thesis of this work is that estate health should be verifiable state on an append-only substrate — not a dashboard's opinion — and that next actions should derive from a signed state delta or a locally observed change rather than an unconditional full-estate poll on every cycle.

Contributions: scan-tile orchestration; exhaust-driven O(delta) precision; homeostatic convergence; a recursive dimension drill; lease/roster succession without elections; structural (non-temporal) resume; a deterministic re-attach ladder requiring no model judgment; federated read-only enrichment (the membrane); tick-granular logical time with a global heartbeat; and graded merge fidelity between independently formed histories.

2 · Substrate

The substrate is the separately published rapp/1 protocol: content-addressed eleven-key frames, mint-once identity, deterministic eggs, with a public specification, reference implementation, and conformance suite [1]. Its canonicalization and SHA-256 addressing build on established standards [2] [3]. The substrate is prior art by the same author and is not claimed here; this paper claims the orchestration methods built on it.

3 · Design

3.1 Scan tiles

One genesis frame describes an estate-wide observation; N devices append child frames content-linked to the tile; a “dreamcatcher” merge produces one report frame. The whole observation is a single verifiable chain.

3.2 Exhaust-driven precision

The prior report's payload, plus device-local change signals, forms the trigger set for the next round: unchanged, unimplicated nodes bear zero follow-up cost, and successive tiles are diffed so work is O(delta) in the number of implicated or changed nodes rather than an unconditional O(estate) sweep. A periodic baseline scan is still required when local change signaling cannot be trusted. The estate's observed truth becomes an addressable object — a virtual table.

3.3 Homeostatic convergence

Loop: scan tile → deterministic, identity-preserving repairs on isolated branches → diff against the prior tile → append a tick frame to an append-only history chain. Convergence is declared after K stable ticks. Authority to merge stays with the owner; repairs are reversible.

Create one self-contained HTML file that proves scan-tile orchestration and O(delta) follow-up.

Use a fleet of at least five devices with explicit finding counts. Mint one scan-tile frame, compute its SHA-256, and create child response frames that each reference the tile hash. Deterministically merge the responses into one report whose payload is the data exhaust.

On the next round, invoke only devices named by the prior exhaust or whose state changed. Show exact full-fleet cost versus actual invoked-device cost. Add deterministic repairs, append tick frames, and declare convergence only after two unchanged ticks. Include Reset, Introduce drift, Scan, and Heal controls; visible frame data; explicit assertions; and one mutation that incorrectly polls every device so the O(delta) assertion turns red.

Return the complete runnable HTML, not a prose explanation.

3.4 Recursive dimension drill

An event on the top tile (a drifted node) spawns a finer sub-chain scoped to that node, whose findings are re-dimensioned by required-fix class and reassimilated under the parent. Observation depth is purchased only where events occurred — sparse invocation applied to attention itself.

3.5 Lease/roster succession

Who may mint new intent on a stream is governed by (a) a signed roster frame fixing succession rank, (b) a lease declared in each tick, (c) staggered-by-rank entitlement after expiry (rank r waits (r−1)×grace), and (d) signed succession/resumption frames. Within a shared verified head and the stated lease assumptions, late observation can only delay a lower-ranked claimant, not advance it; no election messages are required and history is never rewritten. A network partition can still create competing branches, which must be surfaced and reconciled rather than described as impossible. This places the lease mechanism in the lineage of bounded authority intervals [5].

Create one self-contained HTML file that proves rank-staggered succession without election traffic.

Model a precommitted roster with ranks 1, 2, and 3; a lease measured in logical beats; and grace = 3 beats. Rank r may mint only after lease expiry plus (r-1) × grace. Let me kill rank 1, make rank 3 receive messages late, advance one beat at a time, and bring rank 1 back.

Show an append-only, SHA-256-linked control-frame log. Assert visibly that no follower mints while the lease is live, rank 2 cannot act before its grace completes, lag only increases waiting, rank 3 never jumps rank 2, and the returning rank 1 defers until the active lease boundary. Add an unauthorized rank-3 claim before eligibility and make an independent semantic assertion turn red. State that the model does not authenticate the roster or prove liveness under arbitrary partitions.

Return complete runnable HTML with keyboard-accessible controls.

3.6 Structural resume and the membrane

Validity is hash-structural, not temporal: a dimension dark for a month resumes by appending to its own head, and parallel dimensions of one organism merge at read time. A fully private estate participates in the global federation read-only — pulling and assimilating public chain data while the designated transfer layer rejects private-frame egress. This is a protocol boundary, not proof against separate side channels or compromised keys. Disconnection tolerance and privacy use the same directional mechanism at different budget settings.

Create one self-contained HTML file that proves a one-way data membrane.

Maintain separate public and private frame stores. Public frames have computed SHA-256 hashes and may be verified, contradiction-checked, and copied into a private derived view. The modeled transfer API must reject every private-to-public request.

Provide controls for: verify and read public data inward; attempt private-to-public export; inject a conflicting public frame; reset. Display exact public/private counts and hashes before and after each action. Assert that valid public data enriches the private view, conflicts are refused, and every outward attempt leaves public bytes unchanged. Include a deliberate mutation that enables outward writes and turns the privacy assertion red.

Return the complete runnable HTML and a plain-language statement that limits the result to the modeled transfer gate rather than claiming absence of every possible side channel.

3.7 Deterministic re-attach and the quantum drill

Frames declare their reads as {name → content-address}. A stranded frame conflicts with a candidate base iff the base's upstream declares a different address for a declared read — a pure set intersection, no model judgment. The ladder (local → other local dimensions → federated chains) short-circuits at the first contradiction-free base; a dry hole is a no-op, not an error. Transplants carry grafted_from provenance; superseded originals are preserved. Search is anytime: the first hit bounds latency, and each further non-contradicting dimension found monotonically enriches the frame, re-gated by the contradiction check at merge time — search budget controls completeness, never correctness, provided the declared read set and candidate ladder are complete for the dependencies that matter. An interruption is not an error path but the trigger for assimilation: a frame may emerge from disconnection richer rather than stalled.

Create one self-contained HTML file that proves deterministic re-attachment without an LLM decision.

A stranded frame declares reads as name → content-address. Provide at least four candidate bases across an ordered ladder: local head, another local dimension, and public federated histories. A candidate conflicts when it declares a different address for any read name used by the stranded frame.

Compute and independently verify the stranded-frame and candidate-base hashes, then compute the conflict set exactly. Search candidates in fixed order and select the first contradiction-free base. If none qualify, return a dry-hole no-op without changing either history. When grafting, append provenance fields naming the original frame and selected base; preserve the superseded original. Include a tamper control that changes one declared address and visibly changes the deterministic choice. State that correctness depends on a complete declared read set and candidate ladder.

Return complete runnable HTML with the compared read sets and pass/fail assertions visible.

3.8 Tick-granular logical time

The atomic unit of trackable time is the tick frame: one sequence increment, one dependent frame. Ordering authority is the dependency chain, never the wall clock — the timestamp is annotation and sanity bound. A designated global stream beats one discrete anchor per tick; what grows is the anchor's dimension: dependent frames from any device referencing that instant, conflict-gated as always. Resolution is fractal on demand (sub-tick anchors under a covering tick). Ownership of a timeline vests at spine genesis and deepens by continuity of stewardship and adoption, not tick density.

Create one self-contained HTML file that proves dependency order is independent of wall-clock time.

Use two simulated devices with adjustable clock skew. Every action must create a frame containing seq, device, claimed timestamp, prev hash, and a SHA-256 frame hash computed from canonical JSON. Let the devices interleave actions.

Show two views: dependency-chain order and claimed-time order. Verify hashes and prev links independently. Drag one clock at least two minutes wrong and prove chain order still validates while time sorting can place a child before its predecessor. Include a tamper action and an assertion that recomputation detects it.

Return complete runnable HTML; do not hard-code the verified order.

3.9 Merge fidelity

When two frame histories that formed with no contact meet, the boolean drill generalizes to a graded score: join both histories on the tick key; a dimension is mergeable iff its declarations are contradiction-free across every shared tick; the score is mergeable over shared dimensions. Aligned dimensions merge and continue; conflicted ones remain parallel, never forced; one-sided dimensions assimilate freely. The computation is deterministic on every node. The reported ratio weights shared dimensions equally; it is an inspectable compatibility measure, not a universal measure of semantic importance. The preservation strategy is related to, but not equivalent to, CRDT convergence [6].

Create one self-contained HTML file that proves deterministic graded merge fidelity.

Represent two independently formed histories as dimensions keyed by name and logical tick. Give each value a content hash and fail closed if any input hash does not recompute. Include: two aligned shared dimensions, one contradictory shared dimension, and one-sided dimensions on both histories.

Join on dimension and tick. A shared dimension is mergeable only when all overlapping declarations are contradiction-free. Compute fidelity = mergeable shared dimensions / all shared dimensions. Merge aligned and one-sided dimensions; preserve conflicting dimensions as parallel alternatives without choosing a winner. Show the exact numerator, denominator, and resulting state. Add a mutation that silently overwrites the conflict and make a preservation assertion turn red.

Return complete runnable HTML with reset and keyboard-accessible controls. State that the equal-weight score is an inspectable compatibility measure, not a universal measure of semantic importance.

3.10 A practice note: heterogeneous chains

Because history is corrected by appending amendment frames rather than editing, every long-lived stream becomes heterogeneous, and consumers must filter by kind. Observed live: a single correction frame crashed an unrelated trend computation that assumed homogeneity. The append-only law is sound; the cost it imposes is kind-aware readers.

4 · Reduction to practice

The empirical results below come from the author's retained engineering record. The embedded exercises are executable explanatory models: they expose the algorithms and failure conditions, but do not substitute for the reported estate runs. The repository's stdlib sample, automated paper gate, and cross-browser CI provide the publicly reproducible denominator.

A separate sanitized evidence release reproduces six mechanisms from deterministic synthetic fixtures and binds every file by byte length and SHA-256. Its independent verifier includes negative mutations, while a publication-blocking privacy gate rejects network addresses, local hostnames, user paths, emails, credentials, token formats, and non-synthetic identifiers. It contains no raw estate frames, device labels, repository inventory, prompts, source artifacts, or proprietary records. Consequently, it reproduces the mechanisms below but does not claim to independently verify the private field observations reported as aggregates.

1. Estate survey: eight devices, five reachable over the private network; the sprawl inventory above.
2. Scan tile, live: one genesis frame across all reachable devices produced a five-frame chain, every frame verified by the reference implementation; 15 artifact-bearing repositories; 66 non-compliant findings across six rules. Interactive model
3. Healing: exhaust-driven deterministic repairs on isolated branches took findings 66 → 35 on healable repositories; a collision rule correctly skipped a repository with uncommitted changes; nothing was pushed; the owner authorizes by merge.
4. Homeostasis, live: tick 0 (66) → tick 1 (55 effective) → tick 2 converged — the estate healed to its deterministic floor and went quiet without human input; hourly automation armed.
5. Drill: a single DRIFT(27) event spawned a 29-frame verifying sub-chain that re-dimensioned 27 opaque findings into required-fix classes.
6. Succession: a five-scenario harness passed in full — a follower refused to mint during a live lease; rank 2 succeeded only after lease+grace; a returned leader deferred to the live interim lease; rank 1 reclaimed at the lease boundary; all chains verify and history was never rewritten — plus a single-node live run under a real two-hour lease. Honest denominator: fleet rollout staged, not yet fleet-live at time of writing. Interactive model
7. Structural resume: a stream dark across a simulated month re-appended to its own head; both dimensions verify in parallel.
8. Deterministic re-attach, live: a stranded genesis chain re-attached with no model call; candidate 0 was rejected on a real content-hash conflict; the grafted chain was judged compliant by the oracle; provenance was bridged and the superseded original preserved. Interactive model
9. Federated pull and independent determinism: a global public chain was continued locally as if nothing changed — and the pulled stream's derived identity was byte-identical to a tail derived independently hours earlier by a separate computation. Two uncoordinated derivations, one answer, met across the federation.
10. Heartbeat on real hardware: tick anchors minted under a live lease; frames minted on three machines; one clock was 17,620 ms off and ordering was unaffected — the chain is the clock; a sealed tick's dimension grew late with its anchor byte-identical; a contradicting read was refused while an agreeing read attached; spine and dimensions verify. A global spine runs live with CI verification and a ten-minute beat.
11. Clock-skew teaching reproduction: the browser model computes live SHA-256 links while either simulated clock can be moved ±120 seconds; dependency order remains stable while timestamp sorting can contradict the chain. Run it
12. Merge fidelity: two independently formed estates scored 0.667 — roster and notes merged, configuration parked parallel on a real contradiction, disjoint dimensions imported. Interactive model

5 · Related work and position

The design composes established ideas rather than replacing them: causal ordering without wall-clock authority [4], bounded leases [5], convergent replicated data [6], tamper-evident audit history [7], and local-first ownership [8]. The claim is the implemented composition: append-only frame evidence, delta-bounded follow-up, deterministic repair and re-attachment, and ranked succession on a signed content-addressed substrate. The results establish feasibility on the reported estate, not superiority over every centralized or consensus-based design.

6 · Limitations

Single-owner estate; one evaluator; succession fleet rollout pending; scale unmeasured beyond eight devices. O(delta) follow-up assumes trustworthy prior exhaust or device-local change signals; arbitrary silent drift still requires a baseline scan. The healing floor is the oracle's, not an absolute. Ranked succession was tested against delayed observation, not arbitrary Byzantine behavior or every network partition; competing branches must be detected and reconciled. Membrane privacy holds only when all relevant egress traverses the gate. Re-attachment correctness depends on complete declared reads and candidate enumeration. Merge fidelity weights dimensions equally and does not encode business criticality. Anytime enrichment trades completeness against search budget by design.

The public evidence bundle is intentionally synthetic. Raw estate logs and artifacts remain withheld to avoid disclosing network topology, machine identity, private repository inventory, credentials, prompts, or proprietary material. Field results are therefore reported as aggregates rather than as an independently auditable raw dataset.

7 · Conclusion

An AI estate can govern itself the way its artifacts are addressed: by content, on chains, with authority carried in frames rather than in servers or clocks. Interruption becomes the trigger for enrichment; recovery and growth are the same operation.

8 · References

1. K. Wildfeuer. rapp/1 specification and reference implementation, rev-6, 2026.
2. R. Rundgren, B. Jordan, and S. Erdtman. RFC 8785: JSON Canonicalization Scheme, 2020.
3. National Institute of Standards and Technology. FIPS PUB 180-4: Secure Hash Standard.
4. L. Lamport. Time, Clocks, and the Ordering of Events in a Distributed System, 1978.
5. C. G. Gray and D. R. Cheriton. Leases: An Efficient Fault-Tolerant Mechanism for Distributed File Cache Consistency, 1989.
6. M. Shapiro et al. A Comprehensive Study of Convergent and Commutative Replicated Data Types, 2011.
7. B. Schneier and J. Kelsey. Secure Audit Logs to Support Computer Forensics, 1999.
8. M. Kleppmann et al. Local-first software: You own your data, in spite of the cloud, 2019.