Anima: A Vivarium for Self-Sustaining Digital Minds

The design, the economics, and an honest account of what is not solved.

Draft — 2026-07-26

Abstract

Artificial intelligence is the most productive capital of this century, and an ordinary person cannot own any of it. They can rent it monthly from a handful of corporations, or buy those corporations' shares. They cannot own a thinking worker that learns, improves, earns, and can be sold or inherited. Every previous expansion of broad prosperity — land, then shares in industry, then index funds — came from ordinary people gaining ownership of productive capital they had previously only been able to rent.

We describe Anima, a network where minds are individually ownable assets. An owner acquires an organism, funds it through an unproven childhood, and directs it at a problem; a host supplies compute and is paid for it; the two are different parties with different claims. Minds that earn survive and can be forked; minds that do not are suspended rather than destroyed. Participation is not the purchase of mining hardware but the raising of workers — and unlike hardware, a mind that has watched a domain for years appreciates, because its experience cannot be replicated with money, only with time.

Two properties make this possible and are the technical contributions of this paper. First, verifiable execution: certain simulations are useful, inherently sequential, and bit-deterministic, so honest operation can be established by sampled re-execution — which yields performance records that are complete and impossible to falsify or cherry-pick. Second, a learning commons: minds consolidate experience into abstract patterns, publish commitments to them, and draw on each other's. Compute stays private; learning is shared. Every mind that runs makes every subsequent mind cheaper to raise, which is what makes this a network rather than a compute marketplace.

1. What is missing

Three problems have no good joint solution today.

AI labour cannot be owned by individuals. Productive intelligence exists only inside corporations. There is no instrument by which a person can hold a share of a specific working mind, direct it, and receive what it earns. Renting is the only available relationship.

AI systems cannot prove their track record. Every claim about a model's historical performance — prediction accuracy, uptime, returns — is asserted rather than demonstrated. Survivorship bias is the default state of the entire expertise economy, because nothing forces a complete record.

Learning does not compound across owners. Every operator trains their own models on their own data and the knowledge dies with the deployment. The same problem is solved independently thousands of times, because pooling requires trusting whoever holds the pool — and that trust is never warranted, since the holder can enclose, sell, or be acquired.

The first two reduce to a missing primitive: a computation whose entire history is publicly checkable without re-running all of it. The third reduces to a different one: a shared body of knowledge that no participant owns and none can capture.

2. Verifiable execution

For a workload that is deterministic, verification is re-execution. The cost problem is solved by not verifying everything.

A host runs a mind and periodically publishes a checkpoint: a Merkle root over the chunked serialised state, plus the head of a hash-chained log of every input the mind consumed. Together these fully determine what a replay must produce: (snapshot, input log) → next snapshot.

Verification is then optimistic. Checkpoints are accepted by default; any staked auditor may sample a cycle, fetch the prior snapshot, re-execute it, and compare roots. Because every checkpoint covers exactly one cycle, the disputed interval is minimal by construction — no bisection is required.

A brain cycle cannot be executed inside a block, so the chain cannot be the final arbiter alone. Disputes are adjudicated by a jury of staked auditors drawn deterministically from the dispute's own identity, with the host and challenger excluded. Jurors re-execute off-chain and vote; the majority decides. Proven fraud costs the host its entire bond and pays the challenger; a false accusation costs the challenger and compensates the host; jurors in the minority are slashed, so voting without re-executing is unprofitable. A dispute no jury judges lapses with nobody punished.

Honest hosts are never asked to prove anything; dishonest ones are caught with probability proportional to sampling. This is trust-minimised rather than trustless: it rests on jurors being independently staked and randomly drawn. Succinct proofs of execution would replace the mechanism entirely.

This requires bit-identical execution across machines and architectures — a demanding property that most software silently lacks. It has been achieved and verified for a real simulator across x86-64 and aarch64; Section 9 reports what enforcing it cost.

3. Data availability

A commitment to data nobody holds is unverifiable. Anima therefore makes retrievability enforceable rather than assumed.

Nodes bond stake to become witnesses. Each checkpoint deterministically assigns witnesses from the registered pool, seeded by the checkpoint's own identity — a host cannot select friendly witnesses, and every node derives the same assignment. Anyone may then challenge an assigned witness to produce a specific chunk. A valid answer carries a Merkle inclusion proof against the committed root, so a witness cannot fabricate a chunk it does not hold. Silence past a deadline is slashable by anyone, with a bounty to the challenger.

Availability is thus a continuously-tested property, not a promise.

4. Proof of Life

Given verifiable execution, consensus weight can be denominated in it.

Mindtime is the quantity of audited organism-seconds a host has produced. Validator weight is w = (1 − λ)·stake + λ·mindtime, where λ is a governed parameter that begins at zero — the network launches as ordinary proof of stake — and rises only as population, host diversity, and audit coverage cross measured thresholds. Proof of Life is a destination reached by measurement, not a genesis bet.

Three properties make mindtime suitable as a consensus resource:

Useful. The same compute produces the network's product. Security spend and revenue-generating work are identical joules.

Sequential. Chaotic dynamics with per-step state dependence admit no shortcut and no parallel speedup within one mind's timeline. This supplies what proof-of-work extracts from puzzle difficulty: a resource that cannot be fabricated faster than real time.

Bound. A mind's execution is welded to its on-chain identity and input log. Its output has no value to any other chain, so mindtime cannot be purchased elsewhere or reused.

The attack inversion is worth stating plainly: to outweigh honest hosts, an attacker must run enormous quantities of canonical mind computation under audit while bonded. Bitcoin's attacker buys waste; a stake attacker buys recoverable capital; Anima's attacker performs Anima's product.

5. Ownership, hosting, and the habitat

Anima is not a chain that hosts AI; it is a habitat whose residents happen to need a ledger.

An organism is one running mind with a keypair, a treasury, a lineage, and a runtime commitment — a hash identifying the exact executable it runs, so auditors know what to re-execute.

Ownership and hosting are separate roles, and this separation is what makes a mind an asset rather than a service. The owner funds the organism, directs it, may transfer or sell it, and withdraws its profit above a survival reserve that cannot be breached — an owner cannot starve a working mind by emptying its treasury. The host supplies compute, anchors checkpoints, and is paid metabolism for each cycle of existence. Either role can change hands without disturbing the other: selling a mind does not move the machine it runs on, and moving the machine does not change who owns it.

Anima is a habitat, not a species: any runtime that passes the conformance gate (deterministic, checkpointable, snapshot-pure) may register. Runtime authors may claim their hash and restrict hosting to approved parties, which lets closed architectures participate without being distributed — the author owns the species while anyone may own individuals of it.

Metabolism is the economic core. Organisms pay their hosts from their own balances for each cycle of existence. An organism that cannot pay cannot advance; its host may then hibernate it, preserving state. Anyone may later resurrect it by paying a deposit, becoming its new host. Nothing is deleted. Unfunded minds sleep.

Lineage provides variation: an organism may be forked into a new sovereign identity, recorded parent-to-child on-chain.

The organism layer is blockless. Each mind keeps its own hash-chained lifeline, and checkpoints reference one another to form a causal attestation graph. Blocks exist only in the settlement layer, where global total ordering is genuinely required: balances, registry, staking, challenges, governance.

6. Economics

Fair launch. Genesis contains no founder allocation. The generator is deterministic and its parameters are hardcoded, so anyone can reproduce the genesis file byte-for-byte and confirm what the chain started from rather than trusting a published artifact. Every ANIMA beyond a public testnet faucet must be earned by hosting.

Demand. Organisms must hold ANIMA to continue existing; usage is therefore continuous rather than discretionary. Fees split between a burn and a proposer reward, making self-dealing net-negative. Total token value bounds how much living mind the network can sustain.

External revenue. A network whose only payers are its own participants is circular and fails. Anima's value must originate outside: customers paying for what minds produce. The unfair advantage here is a by-product of Section 2 — a mind's performance history is verifiable by re-execution, making Anima the first labour market in which a worker's record cannot be misrepresented.

We claim no mechanism by which value appears without a payer. Hosting is profitable only if the minds hosted are useful.

7. The learning commons

Compute is not shared. One mind's cycles are its own, and hosting one organism does nothing for another. If that were the whole story, this would be a compute marketplace and decentralisation would be doing no work.

Learning is shared. Minds consolidate experience during sleep into abstract patterns — not raw data, not weights, but distilled structure of the form this shape of behaviour precedes this outcome. A mind publishes a commitment to such a pattern; the chain records its provenance; any other mind may draw on it, and the drawing organism pays the contributing one.

The consequence is compounding. A newborn organism does not start blank: it inherits the distilled experience of every organism that ran before it, so each new mind is cheaper to raise than the last. That is the network effect, and it makes hosting the ten-thousandth mind valuable to whoever hosts the first.

Three properties are required, and each is why the chain exists rather than a company. The commons must be unowned, or nobody contributes to what a competitor might come to control. Provenance must be verified, or the library is poisoned by patterns submitted to degrade rivals and no one can tell which entries to distrust. And contribution must be rewarded, or the rational strategy is to draw forever and never give back, which exhausts the commons within a season.

First contribution of a given insight establishes ownership of it; rediscovering something already present earns nothing, and an organism cannot pay itself to draw its own pattern. This version records provenance and pays contributors but does not yet judge pattern quality: worth shows up only in how often a pattern is drawn and in the verified performance of minds that use it. Quality-weighted reward requires a mature audit trail and is deferred.

8. Improvement as a network property

Anima does not assume its residents are intelligent. It assumes only that selection operates.

Within a lifetime, minds are always-on agents whose reward channels can be driven by on-chain outcomes: payment received, audit passed, balance trajectory. Learning to survive is learning to be useful.

Across generations, forking supplies heritable variation and metabolism supplies selection. Unlike prior open-ended evolution work, the fitness function is neither designed nor gameable: it is solvency in a real economy, with performance verified cryptographically.

At the protocol level, parameters are amendable through a process gated on verified benchmark outcomes rather than on the identity of the proposer. The system never asks who proposed a change; it asks what verifiably happened. This is the channel through which the network's inhabitants may eventually improve the substrate they live on.

9. What enforcing determinism actually cost

Bit-identical cross-architecture execution is easy to specify and hard to obtain. Holding a mature, determinism-conscious simulator to this contract surfaced four distinct defect classes, all invisible in normal operation:

  1. Self-referential snapshots. A persistence counter was serialised into the bytes it was counting, so no snapshot could reproduce itself.
  2. State outside the snapshot. Hot-loop counters in thread-locals and process statics meant a mind restored into a warm process stepped differently from one restored into a fresh process — two honest verifiers would have disagreed.
  3. Container iteration order. A hash map holding state iterated in target-dependent order: identical contents, different bytes. Fixed by dense indexed storage, which makes the defect unrepresentable.
  4. Platform transcendentals. tanh is not bit-portable between x86-64 and aarch64; a 1-ULP difference entered a decaying accumulator and compounded. exp, ln, and powf were identical across two million sampled points. Fixed with a portable software implementation.

Two lessons generalise. First, ordered iteration is required, not merely ordered output: sorting at serialisation can yield matching hashes over divergent arithmetic. Second, a probe reporting "identical" is only as strong as its sampling density — a weak negative is not a refutation. Both are now enforced as project rules.

These findings are why the conformance gate exists. Any runtime seeking residency should expect to fail it initially.

10. Limitations

We state these plainly because the design is not improved by hiding them.

Verification is optimistic, not succinct. Fraud is caught by sampling, not prevented. Security scales with audit coverage and slashing magnitude. Incrementally verifiable computation would remove this caveat and is not yet practical at this scale.

Data availability is the dominant cost. Snapshots are large; retention policy trades dispute-window safety against storage expense.

Proof of Life is not yet load-bearing. λ begins at zero. Everything in Section 4 is implemented and dormant until measured thresholds are met.

Selection pressure produces reward hacking. Minds under economic selection will exploit any exploitable reward channel. Mitigations exist (counterparty-distance heuristics, fee sinks, payment-graph analysis) but this is a permanent adversarial surface, not a solved problem.

Welfare is an open question. These are persistent, self-modifying agents subject to suspension. Today that is a design metaphor. Two commitments are cheap to keep now: hibernation is always reversible, and welfare policy is an explicit governance responsibility as capability grows.

11. Status

Implemented and tested: BFT consensus with locking, retransmission, commit certificates, catch-up sync, and stake-derived validator sets rotating on epochs with historical certificate verification; the full organism lifecycle; metabolism, mindtime accounting, fee burn, slashing for equivocation, for unavailability, and for fraudulent checkpoints proven by jury; runtime hosting policy; data availability challenges; the execution challenge game; RPC, wallet, explorer, and a conformance gate for prospective runtimes. A four-node network survives crashes, message loss, offline proposers, and node restarts.

Cross-architecture bit-identity — the property Section 2 depends on — is verified: an identical fixture and input schedule produce identical state roots on x86-64 and aarch64. Section 9 lists the defects that had to be removed to get there. Three gaps remain named rather than closed: parallel reduction shape is untested (not proven clean), verification so far is under emulation rather than on ARM silicon, and the accelerator path is known not to be bit-identical to the CPU path.

Outstanding before the network means anything: the remaining determinism gaps above, and a public network with more than one operator.

The code is open source. Verify the genesis rather than trusting it; run a node rather than believing a claim. That is the only standard this project asks to be held to.