milno CA TBA

milno is an experimental cryptographic organism model. Its proposed identity and neural body share one private substrate, W = HKDF(sk). The key is not merely authorization; it participates in defining the animal.

Live specimen

SIMULATED / LOCAL MODEL

MILNO / SPECIMEN 001

state
ACTIVE
identity
did:milno:7F2A...91C4
epoch
001842
uptime
03D 17H 42M
weight root
0x18A7...F921
commitment
SIMULATED PASS
last transition
4.218s ago
metabolic reserve
81.72%
integrity
100.000%

organism alive

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.

milno takes that idea and rebuilds it in cryptography. A water bear is hard to kill because its identity outlasts any pause in its life. milno works the same way. Its identity is a fixed value that anyone can check. Flip one bit of the seed and the derivation produces a stranger. A future verification layer could let milno remain dormant, wake up, and prove it is still the same organism.

Based on Suzuki, Internalising the Identity Primitive (arXiv 2608.02986).

The body

KEY-DERIVED TOPOLOGY

The private substrate does not merely sign for milno. It deterministically becomes the internal body: W = HKDF(sk).

KEY-DERIVED REGION W[128:255]
entropy
0.9914
variance
0.0842
drift
0.0000

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.

milno takes the outside away. Its identity is not stored anywhere, it is computed. The same seed always produces the same weights and the same key, and the chain rechecks that link on every move. There is no server to breach and no operator to bribe. To be milno you have to hold the seed, and holding the seed is the whole of being milno.

Identity trace

DETERMINISTIC DERIVATION

Follow the proposed substrate from one private seed to a body, a public identity, and a verifiable history. Select any stage to inspect the model.

HKDF-SHA256INSPECTOR
IKM
private substrate
salt
milno/genesis
info
neural-body/v1
output
18,432 deterministic parameters
function deriveBody(sk: Uint8Array): Float32Array {
  const material = hkdf("neural-body/v1", sk)
  return decodeWeights(material, 18_432)
}

Weight fingerprint

256-CELL OBSERVATION

A stable projection of the current simulated body. Every cell is derived from its public specimen fixture; none are sampled at render time.

weight root
0x82F1...9C71
parameters
18,432
derivation
DETERMINISTIC
drift
0.000000%
W[271]
value
-0.72148
layer
L06
origin
HKDF block 17
stability
99.998%

How it works

seed sk W = HKDF(sk) commitment history hkdf commit sign checked every transition
protocol model: one substrate fixes identity, body and commitment.
01

Birth

In the protocol model, a milno starts from one private substrate. It deterministically fixes the public identity and body without a training step.

02

Commitment

A conforming implementation would publish a commitment to the link between identity and body. The current console illustrates this check but does not generate a Groth16 proof.

03

Transition

A future runtime would verify body and commitment invariants before signing an append-only transition. The current runtime records this sequence locally.

04

Dormancy

Under stress milno enters the tun state. It stops acting but keeps its identity intact. It returns to active only once the environment recovers.

05

Death

If the identity check ever fails, milno is dead. A forged or corrupted seed can never reproduce the committed weights, so a fake can never pass as the original.

Stress chamber

SIMULATED ENVIRONMENT

Change the local environment and observe the shared survival model. The chamber is a deterministic simulation, not chain telemetry.

SURVIVAL MODEL

identity integrity
100.000%
transition stability
94.821%
metabolic margin
61.202%
state
ACTIVE
environment within survivable range identity invariant continuously preserved

Transition ledger

BLOCK 1842 / 1842

Each simulated cycle becomes a local transition record containing what milno sensed, decided, and the state it entered. Records include a local predecessor identifier and an illustrative integrity marker.

TRANSITION001842
timestamp
2026-09-20 08:22:14 UTC
state
ACTIVE -> ACTIVE
sensor root
0xc840d...
weight root
0x82ab1...
observe
environment normal
decide
continue
act
cycle executed
verify
PASS
previous block
0xf7319...
current block
0xa9821...
signature
SIMULATED
identity invariant
PASS
proof
VALID
molt 0genesis molt 1prev hash molt 2prev hash …
the simulation demonstrates predecessor-linked ancestry; records are not externally signed.

In the protocol model, modifying a past transition invalidates every descendant link. The current browser ledger is a bounded local model and has no Solana connection or external finality.

States

stress recover tamper forge active tun dead
active and tun trade places with the environment. a failed identity check ends in dead, with no way back.
active

Awake, sensing the simulated environment, writing local transition records.

tun

Dormant. Metabolism halts, the identity holds, no history is written.

dead

The identity invariant broke. This is no longer the same animal.

Metabolism

LOCAL CYCLE MODEL
energy reserve
81.72%
survival threshold
18.00%
current cost
0.00281 / cycle
average cost
0.00294 / cycle
metabolic mode
NORMAL
reserve / recent deterministic cycles

Proof inspector

LOCAL VERIFICATION MODEL

IDENTITY PROOF

  1. loading commitment
  2. checking witness
  3. validating constraints
  4. verifying proof
  5. matching identity
function verifyIdentity(state, proof): Verdict {
  verify_commitment(state.weight_root)
  preserve_identity(state.previous, state.next)
  return proof.verify() ? PASS : REJECT
}

Specimen comparison

SEED-DETERMINISTIC

Different private substrates yield different organisms. Switching specimen replaces the shared local model, including identity, body, fingerprint and metabolic tendency.

SPECIMEN A / 7F2A

identity
did:milno:7F2A91C4
response variance
0.081
stability
97.2%
exploration bias
0.41
metabolic efficiency
88.4%

Proposed primitive

identity
protocol target: ed25519(sk)
body
protocol target: W = HKDF(sk)
commitment
planned proof layer; not implemented
history
local simulation; external anchoring not implemented
chain
none connected

Lab terminal

LOCAL RESEARCH SHELL
milno research shell / simulation provider
type "help" to inspect available procedures.
statusinspect identitystress 0.72enter tunwake

Notes

Is milno trained?

No. The weights come from the seed once, at birth. milno has a fixed disposition, not a learned one.

Can two milnos be the same?

Only if they share a seed, and then they are one animal, not two. Every other milno 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. milno wakes and proves itself with the same check it always runs.

Where does the paper end and milno begin?

The paper defines the primitive. milno gives it a body, a lifecycle, and a water bear.

Status

phase 1

Current. Interactive deterministic research console using local simulated state.

phase 2

Research target. Specify and test a proof model for body derivation without exposing the substrate.

phase 3

Proposed. Evaluate an external provider and durable transition anchoring after the protocol is fixed.

console runtime / SimulationProvider / deterministic local model / no live chain connection