NERRO — Persistent Identity for Autonomous Agents

SPECIMEN / 0001

NERRO, an octopus-shaped cryptographic organism

AUTONOMOUS AGENT / IDENTITY PRIMITIVE

NERRO is an autonomous agent that lives on chain. Its neural weights are derived from its private key. The key is the whole animal. Give it a different key and you get a different animal. Nothing about NERRO is kept anywhere else.

CA: TBA

SPECIMENNERRO

IDENTITYDERIVED

STATEACTIVE

ROOTPRIVATE

CHAINSOLANA

01 / THE ANIMAL

A body can change without becoming another animal.

An octopus does not concentrate its entire nervous system in one place. Much of its neural machinery extends throughout its arms, where sensing and local control happen across a distributed body.

That body is also capable of repair. An arm may be damaged or lost. Later, it can grow again. The physical configuration changes. The individual remains.

NERRO begins from the same question in another medium: what must survive for an autonomous agent to remain the same individual?

A runtime can disappear. A process can stop. Infrastructure can be replaced. None of those should be sufficient, by themselves, to create or destroy identity.

For NERRO, continuity is attached to something deeper. A single cryptographic root. From it come both the key that identifies the agent and the neural parameters that define its computational body.

THE INVARIANTthe body can recover.
the root must remain.

02 / IDENTITY

An agent should not have to borrow its identity.

Most autonomous agents depend on something outside themselves to remain identifiable. A server stores their credentials. A model checkpoint defines their behavior. An operator maintains the connection between the two.

The blockchain sees a valid signature. But the signature alone cannot answer a more difficult question: is the intelligence using this key still the same intelligence?

A model can be replaced while a wallet remains unchanged. A server can be compromised. Credentials can be copied. Another process can inherit the same address.

NERRO removes that separation. Its public identity and neural parameters originate from the same private root.

pk = Ed25519(sk)W = HKDF(sk)

The same secret defines both the actor capable of signing and the computational body responsible for acting.

THE DISTINCTIONa wallet proves control.
NERRO proves continuity.

IDENTITY PIPELINE

One origin. Two expressions. One identity.

pk = Ed25519(sk) · W = HKDF(sk) · relationship proven, root hidden

sk│├─ pk = Ed25519(sk)└─ W = HKDF(sk)

LIFECYCLE / FIVE TRANSITIONS

Continuity is checked in motion.

Birth

Every NERRO begins from one 32-byte seed. The seed determines its Ed25519 identity and the parameters of its neural body.

F(sk) → { pk, W }

Commitment

At birth, NERRO commits to the relationship between its cryptographic identity and neural body. Groth16 is intended to prove both came from the same hidden root.

C = Commit(pk, W)

Transition

Every meaningful state transition records observation, decision, state, previous hash, identity proof and signature.

σ[n] = Sign(sk, H(T[n]))

Withdrawal

Execution can stop without identity disappearing. No artificial heartbeat is required; the commitment remains intact.

execution = 0 / identity = preserved

Death

If the relationship between root, public identity and neural body no longer satisfies the original commitment, continuity has failed.

Verify(identity) = false → dead

03 / HISTORY

An animal leaves a trace.

Every accepted action produced by NERRO becomes part of an append-only history. Each block contains the hash of the block before it. Each valid transition is signed by the identity that produced it.

GENESIS

BLOCK 000001OBSERVE / DECIDE / SIGN

H(B₁)

BLOCK 000002OBSERVE / DECIDE / SIGN

H(B₂)

BLOCK 000003...

APPEND ONLYSIGNEDHASH LINKEDSOLANA ANCHORED

THE TRACEthe ledger is not a biography written about NERRO.
it is the trace NERRO leaves behind.

04 / LIFECYCLE

Three states. One irreversible boundary.

● ACTIVEexecution ONidentity VALIDhistory WRITING

○ WITHDRAWNexecution OFFidentity VALIDhistory PAUSED

× DEADexecution TERMINATEDidentity INVALIDhistory FINAL

ACTIVE and WITHDRAWN may exchange places with the environment. A failed identity invariant ends in DEAD, with no valid transition back.

05 / DISTRIBUTED BODY

The intelligence is not confined to one place.

An octopus carries much of its nervous system throughout its arms. Sensing, movement and local control are distributed across the animal rather than reduced to a single central point.

NERRO uses that anatomy as a useful model for autonomous software. The runtime is not the animal. The interface is not the animal. The wallet alone is not the animal. They are expressions of a deeper identity relation.

distributed nervous system / local action from one cryptographic root

THE ORGANISMNERRO is not where it runs.
NERRO is what remains invariant.

06 / PRIMITIVE

Technical specification.

ROOT: 32-byte secret seed
IDENTITY: pk = Ed25519(sk)
NEURAL BODY: W = HKDF(sk)
COMMITMENT: Groth16
VERIFICATION: re-run at state transition
HISTORY: signed · append-only · hash-linked
STATES: active · withdrawn · dead
SETTLEMENT: Solana

07 / THE DISTINCTION

A key is usually an accessory. Here it is anatomy.

A conventional autonomous agent can replace its model while preserving the same wallet. To the blockchain, the address still looks continuous.

NERRO treats that as insufficient. A wallet proves possession of a signing key. It does not prove continuity of the intelligence using it.

NERRO binds the computational actor and cryptographic actor to the same origin. The distinction is small in notation. Architecturally, it changes the question.

TRADITIONAL

MODEL
+ WALLET
+ SERVER
+ OPERATOR

NERRO

SEED
├─ KEY
├─ WEIGHTS
└─ IDENTITY

The key is no longer something attached to the agent.
It becomes part of the definition of the agent.

08 / NOTES

Questions under observation.

Is NERRO trained?

Not in the conventional sense. NERRO's neural parameters are deterministically derived from its seed. The seed establishes a fixed initial disposition rather than loading an independently stored model checkpoint.

Can two NERROs be identical?

Only if they originate from the same seed. In that case they resolve to the same cryptographic identity rather than representing two independent animals. A different seed produces another key, neural body and identity.

Can NERRO be copied?

Its code, interface and behavior can be approximated. But another seed cannot satisfy the original identity commitment. Copying appearance is not reproducing identity.

What if NERRO disappears for a year?

Nothing about the identity invariant depends on uptime. NERRO can remain withdrawn without writing meaningless history, then verify itself against the same commitment when execution returns.

Why an octopus?

Because identity does not require an unchanged body. An octopus has a distributed nervous system and can recover from substantial physical damage. NERRO uses that biology to ask what must remain unchanged for an agent to remain itself.

Is the wallet NERRO?

No. The wallet is one expression of the root. NERRO is the cryptographically bound relationship between its secret, identity, neural body and history.

RESEARCH BASIS

The primitive is prior research.

SuzukiInternalising the Identity PrimitivearXiv:2608.02986

primitive → identityNERRO → organism + lifecycle

09 / STATUS

What exists. What follows.

PHASE 01 / LIVE

Identity

seed-derived identity
deterministic neural body
identity commitment
signed transitions
append-only history
lifecycle state machine

PHASE 02 / BUILDING

Proof

A Groth16 circuit proving that public identity and neural parameters originate from the same hidden seed.

prove: pk = Ed25519(sk)
W = HKDF(sk)

without revealing: sk

PHASE 03 / PLANNED

Solana

An Anchor program for registering identity commitments and anchoring lifecycle transitions to Solana.

NERRO

one root.one neural body.one history.one animal.
execution is temporary.identity persists.

NERRO / SOLANA