One seed. One identity.
Concept stage · Static project overview
TUNVIO is a proposed autonomous agent inspired by the water bear. Its design derives neural weights
from a secret seed, W = HKDF(sk). The key
is the whole animal. Give it a different key and you get a different
animal. This repository presents the design; the agent runtime and on-chain program are not implemented here.
Background
The tardigrade is the water bear. It lives through things that kill almost everything else. Hard vacuum. Temperatures close to absolute zero. Ten years with no water. Radiation that would tear apart an ordinary genome.
It survives by shutting down. In a state called cryptobiosis the body dries into a small glass grain, the tun, and its metabolism stops. Add water and the animal comes back. It is the same individual it was before it went to sleep.
TUNVIO takes that idea and rebuilds it in cryptography. A water bear is hard to kill because its identity outlasts any pause in its life. TUNVIO works the same way. Its identity is a fixed value that anyone can check. Flip one bit of the seed and the check fails, and the chain reads it as a stranger. The proposed agent would retain its identity through dormancy, wake up, and verify the same identity.
Based on Suzuki, Internalising the Identity Primitive (arXiv 2608.02986).
Why it exists
An agent that acts on a blockchain needs an identity other people can trust. Today that trust almost always comes from outside the agent. A server holds its keys. An operator vouches for it. A hardware module signs on its behalf. Break into any of those and you can wear the agent like a mask.
The design binds an agent identity to a deterministic derivation. Its public identity is computed from a secret seed. The same seed always produces the same weights and the same key. A future verifier would check that relationship at each transition. The runtime still needs secure seed storage: anyone who obtains the seed can reproduce the identity. Deterministic derivation does not prevent seed theft.
Proposed mechanism
Birth
A TUNVIO starts from one 32 byte seed. That seed fixes the public key and every weight in the network. There is no training and no randomness after birth.
Commitment
At birth TUNVIO publishes a commitment to the link between its key and its weights. The paper builds this with a Groth16 proof. The value is set once and never moves for the life of the agent.
Transition
Every time TUNVIO acts it recomputes its weights from the seed and checks them against the commitment. A passing check is signed and written to a history that only grows.
Dormancy
Under stress TUNVIO enters the tun state. It stops acting but keeps its identity intact. It returns to active only once the environment recovers.
Death
If the identity check ever fails, TUNVIO is dead. A forged or corrupted seed can never reproduce the committed weights, so a different seed should fail the identity check. A copied original seed remains a compromise.
The ledger
Every action TUNVIO takes becomes a block. A block records what TUNVIO sensed, what it decided, and the state it moved into. Each block carries the hash of the block before it and a signature from the seed.
Change any past block and every hash after it breaks. Forge a signature and verification should reject it without the signing key. Hash links reveal edits relative to a trusted head; they do not prevent the seed holder from signing alternate histories. Solana anchoring is planned, not implemented.
States
Awake, sensing the environment, writing signed transitions to its history.
Dormant. Metabolism halts, the identity holds, no history is written.
The identity invariant broke. This is no longer the same animal.
Primitive
- identity
- ed25519(sk), published as did:TUNVIO
- body
W = HKDF(sk)- commitment
- Groth16 proof — planned
- history
- signed hash chain; Solana anchoring planned
- chain
- Solana devnet — planned
Notes
Is TUNVIO trained?
No. The weights come from the seed once, at birth. TUNVIO has a fixed disposition, not a learned one.
Can two TUNVIO agents be the same?
Only if they share a seed, and then they are one animal, not two. Every other TUNVIO is a different seed and a different weight set.
What if it sleeps for a year?
Nothing changes. The tun state has no cost and no clock. TUNVIO wakes and proves itself with the same check it always runs.
Where does the paper end and TUNVIO begin?
The linked paper is a design reference. This repository contains the project website; a runtime, proof circuit and on-chain lifecycle are future work.
Status
Planned. An off-chain prototype for seed-derived identity, weights, signed history and lifecycle transitions. No runnable agent is included yet.
Planned. A Groth16 circuit that proves the weights come from the seed without ever showing the seed.
Planned. An Anchor program that stores the commitment and anchors every transition on Solana devnet.