Variable-Bitrate Worlds: Asynchronous Agent Testing on Heterogeneous Compute

How three independent blockchains, epoch-gated memory, and portable sleeves let you test different AI agents fairly — without requiring synchronous execution, identical hardware, or a centralized coordinator — using spot compute, as and when it's available, across different regions.

1. The Problem: Synchronized Worlds Don't Scale

Most agent testing frameworks make a quiet assumption: every agent experiences the world at the same speed. You spin up a simulation, all agents tick at the same rate, they all see the same state at the same moment, and the test is "fair" because everything is synchronous.

This works on a single machine. It falls apart the moment you want to do any of the following:

• Test agents across different hardware — a GPU cluster in us-east-1 versus a Raspberry Pi on someone's desk in Berlin
• Use spot instances that appear and disappear with market pricing
• Run tests that take hours or days without requiring a single machine to stay up for the entire duration
• Let agents perceive at different rates — an LLM with a 200ms inference loop versus a human-speed agent ticking every 8 seconds
• Compare results across runs that didn't happen simultaneously

The synchronous assumption also creates a centralization problem: someone has to run the coordinator. Whoever runs the coordinator controls what "the world" looks like. Whoever controls the world controls the test results.

ECCA takes a different approach. The "world" isn't a single simulation — it's three independent blockchains running at their own speeds, with consistency proven cryptographically at epoch boundaries. Agents don't need to see the same state at the same moment. They need to provably interact with the same state within the same epoch.

2. Variable-Bitrate Perception

In the human brain, different regions process information at radically different speeds. Your visual cortex processes frames at ~60Hz. Your prefrontal cortex deliberates at ~4Hz. Your memory consolidation happens at ~0.1Hz during sleep. Yet you experience a coherent world despite these different "bitrates."

ECCA models this with four sleeve kinds, each operating at a different tick rate:

Sleeve Kind     Tick Rate    Token Preference         Analog
─────────────────────────────────────────────────────────────────
human           8s           Memory ≫ Compute         Slow, narrative cognition
ai              2s           Compute ≫ Memory         Fast inference (LLM)
mining          event-driven Sync ≫ Routing           PoW participation
memory          every epoch  Memory + Routing         DAG pin maintenance

The critical insight: these agents don't need to tick at the same rate to be tested fairly. An AI sleeve ticking 4x faster than a human sleeve doesn't get an unfair advantage — it just consumes its ComputeToken budget faster. Both are bounded by the same per-epoch token allocation. Both reference the same epoch counter. Both produce events that get folded into the same coherence root.

This is what "variable bitrate" means in practice. The world doesn't run at a single frame rate. Each agent perceives it at its own speed, gated by its own token budget, with its own hardware constraints. The three chains provide the substrate — the ground truth — and the epoch system provides the synchronization boundary where everyone reconciles.

3. Three Chains, Three Independent Clocks

ECCA's world isn't a single database. It's three independent ledgers, each responsible for a different dimension of reality:

Each chain can run on completely different hardware, in different regions, at different speeds. Hippocampus doesn't wait for Medulla to mine a block before accepting writes. Cortex doesn't wait for Hippocampus to replicate before processing transactions. The chains are causally independent within an epoch.

Synchronization happens only at epoch boundaries, when the Thalamus router collects Merkle roots from each shard and submits a coherence tuple to Medulla for PoW finality. One proof-of-work commitment finalizes three independent substrates simultaneously.

4. Epochs: The Logical Clock That Doesn't Require Wall-Clock Sync

The epoch is ECCA's fundamental unit of time. Default: 4 seconds. But here's the important part — it's a logical clock, not a wall clock.

// The tick loop in thalamus-router/src/server.ts
setInterval(async () => {
  // 1. Collect event hashes buffered since last tick
  const evmRootHex  = evmHashes.length  ? merkleRoot(evmHashes)  : '00'.repeat(32);
  const ipfsRootHex = ipfsHashes.length ? merkleRoot(ipfsHashes) : '00'.repeat(32);
  const sleevesRoot = sleeveHashes.length ? merkleRoot(sleeveHashes) : '00'.repeat(32);

  // 2. Compute cross-chain coherence root
  const cross = coherenceRoot({ evm: evmRootHex, btc: '00'.repeat(32), ipfs: ipfsRootHex, sleeves: sleevesRoot });

  // 3. Submit to Medulla for PoW finality
  await medulla.submitCoherenceRoot({ crossRoot: cross, evmRoot: evmRootHex, ipfsRoot: ipfsRootHex, sleevesRoot });

  // 4. Bridge to Cortex via EpochAnchor.commitAnchor()
  // ...
}, EPOCH_INTERVAL_MS);

The epoch doesn't advance because 4 seconds passed. It advances because Medulla mined a PoW block containing the coherence tuple. If Medulla is slow (weak hardware, high difficulty), epochs take longer. If it's fast, they're shorter. The wall clock is advisory, not authoritative.

This means:

• An agent on a fast GPU can perceive hundreds of events within a single epoch
• An agent on a Raspberry Pi might perceive three events in the same epoch
• Both agents' events are included in the same epoch's Merkle roots
• Both are bounded by the same per-epoch token budget
• Neither gets an "unfair" head start because the epoch boundary is when coherence is asserted, not when individual events are processed

Drift: Measuring How Far Behind An Agent Is

Every sleeve maintains a drift counter — it increments on perceive and decrements on sync. If an agent falls behind (its hardware is slow, its network is laggy, its spot instance got preempted), drift grows:

drift = 0          → in sync
drift ≤ DRIFT_MAX  → warning, sleeve.drift event published
drift > 2×DRIFT_MAX → sleeve.desync → coordination residue created

But drift isn't failure — it's information. A desync creates a coordination residue: a bounty that any other agent can claim by providing a proof of the correct state. The system doesn't halt. It economically incentivizes repair.

5. Coherence Roots: Proving Consistency After The Fact

This is the mechanism that makes asynchronous testing possible. At the end of each epoch, the Thalamus router computes:

crossRoot = sha256( "ecca-coh-v1" ‖ evmRoot ‖ btcRoot ‖ ipfsRoot ‖ sleevesRoot )

where:
  evmRoot     = merkleRoot([ txHash for each ECCA contract tx this epoch ])
  btcRoot     = reserved (32 zero bytes in v3)
  ipfsRoot    = merkleRoot([ sha256(cid) for each hippocampus write this epoch ])
  sleevesRoot = merkleRoot([ sha256(type ‖ id) for each sleeve event this epoch ])

This single 32-byte hash commits to everything that happened across all three chains in that epoch. It gets mined into a Medulla PoW block, appended to the Synaptic Field MMR, and bridged to the Cortex EVM via the EpochAnchor contract.

What This Enables For Testing

A test verifier doesn't need to replay the entire epoch. They need only:

1. The anchor for epoch N: (crossRoot, evmRoot, ipfsRoot, sleevesRoot, synapticFieldRoot, medullaHeight)
2. A Merkle proof for the specific event they want to verify — one leaf in one shard

The EpochAnchor contract provides on-chain verification:

// Anyone can call this — it's a public, trustless verification primitive
function verifyShardInclusion(
    uint256 epoch,
    uint8 shard,          // 0 = evm, 1 = ipfs, 2 = sleeves
    bytes32 leaf,
    bytes32[] calldata siblings,
    uint256 indexBits
) external view returns (bool)

This means a test run in Singapore can be verified by a machine in Frankfurt that was never online at the same time. The proof is self-contained. The verification is deterministic. The on-chain contract is the final arbiter.

6. Sleeves: Portable Execution on Whatever Hardware Is Available

A sleeve is a containerized process bound to a Stack (cryptographic identity) by a per-epoch capability key. The sleeve-runtime is deliberately hardware-agnostic:

// sleeve-runtime/src/server.ts — the parametric loop
const SLEEVE_KIND = process.env.SLEEVE_KIND || 'human';  // human | ai | mining | memory

// AI sleeves optionally use Ollama for inference — but fall back to canned prompts
if (SLEEVE_KIND === 'ai' && LLM_PROVIDER === 'ollama') {
  // Call local Ollama API on whatever GPU is available
} else if (SLEEVE_KIND === 'ai') {
  // Canned prompt — runs on CPU, no GPU needed
}

// Human sleeves generate narrative perceptions at 8s intervals
// Mining sleeves join the medulla PoW pool
// Memory sleeves run DAG pin maintenance and reconciliation

Sleeves never own memory. They hold per-epoch capability leases. When a sleeve is decommissioned — because the spot instance was reclaimed, or the hardware died, or the test segment finished — the Stack's identity persists. Its episodic head, its token balances, its CPV coefficients: all survive.

A new sleeve can be spawned on completely different hardware, in a different region, on a different cloud provider, and it picks up exactly where the previous one left off. This is architectural re-sleeving: the embodiment is temporary, the identity is permanent.

7. Spot Compute and Regional Distribution

The three-chain architecture maps naturally onto distributed infrastructure:

Each region runs its own stack of services. The chains replicate across regions via their native protocols (Medulla propagates blocks via P2P, Hippocampus replicates via peer sync, Cortex uses geth's devp2p). NATS JetStream provides the intra-service event bus with 7-day retention.

Why This Allows Fair Testing

Agent A in Virginia and Agent C in Ireland are both perceiving the same world. Not because they share a database, but because:

1. Both write to local hippocampus nodes that replicate to the same DAG
2. Both submit transactions to cortex validators that share the same chain state
3. Both reference the same epoch counter from medulla's PoW chain
4. Both have their events included in the same epoch's coherence root
5. Both are constrained by the same per-epoch token budgets via the TripartiteGame contract

If Agent A's hardware is 10x faster than Agent C's, Agent A can perceive more events per epoch — but it burns through its ComputeToken budget faster. When the budget runs out, it waits. The epoch binding curve ensures tokens can't be hoarded across epochs (exponential decay with a 0.25 floor). The CPV coefficients ensure each agent's specialization is reflected in its token allocation.

The test is fair not because the hardware is identical, but because the resource economy is identical.

8. The Tripartite Game: Provably Fair Resource Allocation

The TripartiteGame contract is the on-chain referee for multi-agent resource allocation. It models three resources — Compute, Storage, and Bandwidth — as a cooperative game with per-epoch budgets:

// contracts/src/TripartiteGame.sol

// 1. Open a game (only the referee/owner)
function openGame(bytes32 gameId) external onlyOwner;

// 2. Each agent registers with per-epoch budgets
function registerParty(
    bytes32 gameId,
    uint256 tokenId,         // StackIdentity NFT
    string label,            // "agent-A", "agent-B"
    uint256 computeBudget,   // max compute per epoch
    uint256 storageBudget,   // max storage per epoch
    uint256 bandwidthBudget  // max bandwidth per epoch
) external;

// 3. All spending goes through consume() — atomic, capped, auditable
function consume(
    bytes32 gameId, uint256 tokenId, uint256 epoch,
    Resource resource, uint256 amount, string reason
) external;

// 4. Anyone can verify fairness — public, trustless, re-derivable
function verifyAllocationFair(bytes32 gameId, uint256 epoch)
    external view returns (bool);

// 5. Emit on-chain audit events
function auditEpoch(bytes32 gameId, uint256 epoch) external;

Every consume() call atomically burns the underlying BandwidthToken and checks the per-epoch cap. There's no way to spend more than your budget. There's no way to hide spending — it's on-chain. And there's no way to dispute the audit — verifyAllocationFair() is a pure function over on-chain state.

9. Needlecasting: Moving State Between Regions for Cost Efficiency

When a spot instance is about to be preempted, or when compute is cheaper in another region, or when an agent needs to be closer to a specific hippocampus node for latency — you needlecast.

Needlecasting is the atomic transfer of a sleeve's executive control from one host to another. It's a six-step saga with full rollback:

Step  Operation                     What Happens                            Rollback
──────────────────────────────────────────────────────────────────────────────────────
1     freeze(source)                Mark source sleeve as dead              unfreeze
2     shard(episodicHead, depth=8)  Collect CIDs via DAG walk               (read-only)
3     pin(shards)                   Durability bond in hippocampus          unpin
4     anchor(saga)                  Emit needlecast.route for thalamus      drop fold
5     reconstruct(target)           Spawn new sleeve, drift=0, sync epoch   restore
6     settle(source)                Debit RoutingToken (cost ≥ 5)           re-credit

The cost model is:

needlecast_cost = 5 + 0.1 × shard_count + 0.5 × |sourceEpoch − targetEpoch|

This creates an economic incentive to needlecast to nearby epochs (low cost) and a penalty for large time jumps (high cost). The target pays nothing — what ECCA calls the "refugee-of-experience principle": re-sleeving is always inbound-free.

Regional Cost Optimization

Consider a 24-hour agent benchmark:

• 00:00–06:00 UTC: Spot GPUs are cheapest in ap-northeast-1 (Tokyo). Run AI sleeves there.
• 06:00–14:00 UTC: Tokyo prices spike, eu-west-1 (Ireland) is cheaper. Needlecast all AI sleeves to Ireland. Cost: 5 + 0.1×shards + ~0 epoch drift. State is preserved. Test continues seamlessly.
• 14:00–00:00 UTC: US East opens up. Needlecast to us-east-1.

The agent doesn't know or care that it moved. Its Stack identity, token balances, and memory graph are the same. The sleeve is just a container. The coherence root proves that the agent's events were included in the correct epochs regardless of which region hosted them.

10. Guaranteeing the Same Code Tests the Same Things

Distributed execution raises an obvious concern: how do you know every node is running the same code?

ECCA addresses this at multiple levels:

1. Content-Addressed Everything

Every memory fragment in the hippocampus DAG has a CID: ecca://<sha256(canonical_json)>@<epoch>. The CID is a hash of the content. If the content differs, the CID differs. If the CID matches, the content is identical. This is enforced by the DAG node's Put() operation — it computes the CID from the content, not from a user-supplied value.

2. Coherence Root Commitment

Every event's hash is included in the epoch's shard-specific Merkle root. The coherence root is a hash of all four shard roots. The coherence root is mined into a PoW block. If any node produces a different event for the same input, the hash changes, the Merkle root changes, the coherence root changes, and the PoW block is different. A divergence between nodes is cryptographically detectable.

3. On-Chain Verification

The EpochAnchor.verifyShardInclusion() function lets anyone prove that a specific event was included in a specific epoch's shard root. The proof is a Merkle path — a sequence of sibling hashes. The verification is deterministic: given the same leaf, siblings, and root, the result is always the same. No code differences can hide behind this verification.

4. Residue System as Divergence Detection

If a node does produce different results — different recall fidelity, different shard contents, different event hashes — the residue system catches it. A historical-non-canonical residue fires when recall fidelity drops below FIDELITY_MIN_DEFAULT. A speculative-divergence residue fires when drift exceeds 2×DRIFT_MAX. A reorg-orphan residue fires when Medulla reorgs invalidate an epoch's anchor.

Each residue carries a bounty. Any participant who provides a proof of the correct state earns a ResidueToken — the only token that doesn't decay. The economic incentive is always toward consistency, never toward hiding divergence.

11. The Gap: Where We Are vs. Where We Need To Be

ECCA v3 is functional. All packages build. All 275 tests pass. The three Go chain forks compile. The contracts deploy. The E2E test runs the full coherence cycle. But there is a concrete gap between "it works on localhost" and "fair multi-region agent benchmarking on spot compute."

12. What It Takes to Get There

The gap between "works on localhost" and "fair multi-region benchmarking on spot compute" is concrete and measurable. Here's the work, in dependency order:

Phase A: Chain Peering (2–3 weeks)

Medulla and Hippocampus currently run as single-instance processes. To run across regions, they need P2P peer discovery and block/node propagation:

• Medulla: Add a gossip layer for block propagation. Each region runs a full node; blocks propagate via TCP. The PoW consensus already handles forks — the longest chain wins, exactly like Bitcoin. The existing chain.go code handles reorgs; it just needs a network transport.
• Hippocampus: Add peer sync for DAG nodes. The existing peers map and AddPeer()/RemovePeer() methods are stubbed out. Implement push-based replication: when a node calls Put(), it pushes the node to all peers. Pin leases replicate with the nodes.
• Cortex: Already handled — geth's devp2p does this natively. Just configure bootnodes across regions.

Phase B: Spot Instance Lifecycle (1 week)

When a cloud provider sends a spot interruption signal (AWS gives 2 minutes, GCP gives 30 seconds), the sleeve needs to:

1. Catch the signal (SIGTERM is already handled by wireShutdown())
2. Trigger an emergency needlecast to a predetermined fallback region
3. If the needlecast completes before termination, the agent resumes elsewhere
4. If it doesn't, the sleeve is decommissioned and can be reconstructed manually from the last synced epoch

The existing wireShutdown() in @ecca/service-base already registers SIGTERM handlers. The needlecasting saga already exists. The missing piece is: detect spot interruption signal → initiate needlecast to a target region → handle the race condition where termination arrives before the saga completes.

Phase C: Cross-Region Hippocampus Sync (1–2 weeks)

The needlecasting saga's step 3 (pin(shards)) assumes the target hippocampus node already has the shards. For cross-region needlecasting, the shards need to be replicated to the target region before reconstruct().

Option 1: Eager replication — all nodes replicate everywhere (simple, expensive). Option 2: Lazy replication with on-demand fetch — the target region pulls missing shards during reconstruct() (complex, efficient). Option 3: Hybrid — pin leases trigger replication to a configurable set of regions (practical middle ground).

Phase D: Benchmark Harness (1 week)

A CLI tool that:

1. Opens a TripartiteGame with configurable budgets
2. Registers N agents, each with their own Stack and CPV coefficients
3. Starts sleeve-runtimes across M regions (via Kubernetes or SSH)
4. Runs for K epochs
5. Collects per-epoch verifyAllocationFair() results from the contract
6. Collects drift metrics, residue counts, needlecast counts, fidelity scores
7. Generates a benchmark report (HTML, same cyberpunk theme)

Every piece of this exists except the orchestration script itself. The contracts are deployed, the sleeve-runtime is parametric, the metrics are exposed via Prometheus, the audit functions are on-chain.

Phase E: Helm Chart Completion (1 week)

Complete the Kubernetes deployment charts so the entire stack can be deployed across multiple regions with helm install. The chart-chains templates exist as a reference; the remaining five charts need Deployment/Service/ConfigMap manifests that mirror the Docker Compose configuration.

Update (9 May 2026): The orchestration gap described above has been partially closed. See the next section.

Addendum: Playfair — The 3-Region Test Harness

The day after publishing the analysis above, we built Playfair — a complete Kubernetes test harness that implements the variable-bitrate thesis in actual multi-node infrastructure. It's named after the Playfair cipher, because the whole point is that fairness is verifiable after the fact, not enforced during execution.

What Playfair Actually Does

Playfair provisions a k3d cluster with 3 labeled agent nodes, each simulating a region with a different cost profile:

• region-storage — cheap storage, expensive compute. Hippocampus gets generous resources (500m/1Gi → 1000m/2Gi). Medulla is throttled with ECCA_DIFFICULTY=6, making PoW mining slow and expensive. Natural home for archivists and memory-keepers.
• region-compute — cheap compute, expensive storage. Medulla gets generous resources (1000m/512Mi → 2000m/1Gi) with ECCA_DIFFICULTY=3, making mining fast. Hippocampus is throttled. Natural home for inference agents.
• region-bandwidth — cheap bandwidth, both others expensive. Cortex gets generous resources for fast EVM tx throughput. Both Medulla and Hippocampus are throttled. Natural home for routing and needlecasting.

Each region deploys its own full set of three chains plus siyana-api and thalamus-router instances pointing at the local chains, with shared Postgres, Redis, NATS, and MinIO in a fourth namespace.

The 6 Agents

Playfair deploys 6 agents — 2 per region — with specialized behavioral profiles:

• Archivist-Alpha (storage, memory sleeve) — pins shards, reconciles, keeps fidelity high. CPV: [0.4, 1.8, 1.0, 0.6, 1.2]. Perceives 30% of ticks, stores 80%.
• Archivist-Beta (storage, human sleeve) — slow narrative agent, detailed memories, rarely moves. Perceives 60%, stores 50%. 8-second ticks (half the speed of other agents).
• Inference-Prime (compute, AI sleeve) — fast inference, burns through compute budget. Perceives 90%, stores only 20% (storage is expensive here). 2-second ticks.
• Inference-Echo (compute, AI sleeve) — frequently needlecasts to storage region when memory budget runs low. 15% route rate.
• Router-Nexus (bandwidth, mining sleeve) — routing specialist, exploits cheap bandwidth. 40% route rate, 20% perceive. CPV: [0.3, 0.3, 1.5, 1.8, 0.1].
• Router-Sentinel (bandwidth, memory sleeve) — watches for residues, routes corrections, earns ResidueToken bounties.

The 9 Scenario Events

This is where it gets interesting. At scripted epochs, the orchestrator triggers events that force the system to demonstrate its resilience properties:

1. Epoch 5: Spot preemption — Inference-Prime's sleeve is decommissioned (simulating a spot instance termination). Its drift accumulates while it's down.
2. Epoch 8: Cross-region respawn — Inference-Prime re-sleeves in the storage region (expensive compute, but at least it's running).
3. Epoch 15: Needlecast home — Spot instance available again in compute. Inference-Prime needlecasts back with its accumulated shards.
4. Epoch 20: Drift spike — Archivist-Beta goes idle for 5 epochs. Drift accumulates to dangerous levels.
5. Epoch 25: Sync recovery — Archivist-Beta returns, burns SyncToken to recover and reset drift.
6. Epoch 30: Shard loss — A shard-loss residue is injected in the bandwidth region. First responder earns a bounty.
7. Epoch 35: Strategic migration — Inference-Echo needlecasts to bandwidth region for cheaper routing during a high-traffic phase.
8. Epoch 40: Epoch surge — All agents perceive at maximum rate for 5 epochs — stress test of the fairness auditing system.
9. Epoch 45: Return migration — Inference-Echo needlecasts back to compute as the surge subsides.

Every epoch, the orchestrator runs a fairness audit. Every needlecast is costed (5 + 0.1×shards + 0.5×drift). Every token burn is tracked. At the end, it outputs a comprehensive JSON with per-agent-per-epoch metrics, which the report generator renders into a cyberpunk HTML report.

What This Proves

Playfair isn't a simulation. It runs actual chain nodes, actual K8s resource limits, actual cross-namespace networking. When region-compute's Medulla mines a block at difficulty 3, it actually mines faster than region-storage's Medulla at difficulty 6. When Inference-Prime needlecasts from compute to storage, its shard data actually moves across K8s services.

The thesis from this blog post — that you can test agents fairly across heterogeneous hardware without synchronous execution — is now testable with one command:

pnpm test:playfair --epochs 20

Conclusion

The fundamental bet of ECCA is that you don't need synchronous execution to have fair testing. You need cryptographic proof of consistent state at well-defined boundaries. The epoch is the boundary. The coherence root is the proof. The TripartiteGame is the referee. The sleeve is the portable execution unit. The token economy is the resource constraint.

An agent running on a $0.30/hr spot GPU in Singapore and an agent running on a $2.50/hr reserved instance in Virginia can both participate in the same benchmark. Neither needs to trust the other. Neither needs to trust a central coordinator. The smart contract verifies fairness. The coherence root verifies consistency. The residue system economically incentivizes repair of any divergence.

The world isn't synchronized. It's coherent. That's the difference.

All test results are available in the unit test report (275 tests across 6 suites), the E2E report (full coherence cycle), and the Playfair report (3-region tripartite game). The contracts, including TripartiteGame and EpochAnchor, have 135 Solidity tests covering all verification primitives. Source: github.com/aarong11/dhf.