Skip to content

Signed revisions

A signature lets you put your name to the exact words of a node. Anyone who reads the node later, whether a person or an agent, can see that you confirmed this title, abstract and content, and whether any of it has changed since.

Getting one is a conversation, not a procedure. Tell your agent "ask me to sign the deployment policy", and the agent creates a signing request and hands you a link. You open the link and sign on a page Hadron hosts, with your passkey. The agent can ask, but it can never sign.

Signing is switched on at hadronmemory.com. A deployment you run yourself turns it on with PASSKEY_SIGNING_ENABLED=true, and passkey registration with PASSKEY_REGISTRATION_ENABLED=true as well; both are off by default. GET /capabilities on a server lists node-signing, grant-signing and passkey-registration when they are on. grant-signing comes on with the same setting as node-signing.

This page explains what a signature is and how to read one. The exact tools, fields and refusals are in the MCP tools reference.

Why a person, and why a passkey

Most of what happens in a memory can be done by an agent working for you. A signature is the one thing that deliberately can't be. Its whole value is that a specific person, present at their own device, confirmed specific text.

So a signature is a passkey assertion with user verification: your device checks that it's you, by fingerprint, face or PIN, before it signs. An agent holding your API key or your session can't produce one, because the key or session isn't what signs. No tool takes a signature as input, and signing happens only on the Hadron-hosted page, never inside an agent conversation.

Only a person can sign, and only someone who can write to the node's memory. A reader can ask for a signature but can't give one.

What a signature covers

A signature covers the node's title, abstract and content as they stood at the revision it was made on. It goes on covering every later revision, until the first change to any of those three. Changing tags, properties or the node's place in the tree doesn't touch the signature.

Once the text changes, the signature still verifies, but it's now about words the node no longer says. It reads as earlier. This is permanent: restoring the old text never makes it current again. If the restored text should carry a signature, someone signs it again.

This is the same discipline approval and minting follow (see Product specs and citations). A signature is still not an approval:

  • It isn't access control. It grants nothing and changes nobody's rights.
  • It isn't a lock. Writers can still edit a signed node. The edit just turns the signature into an earlier one, in plain view.
  • It isn't a change to the node. Signing leaves the node's content and revision alone.

Asking for a signature

An agent, or anyone who can read the node, asks through a signing request. The request pins the node's current revision, and it either names one person to sign or leaves it open to any writer of the memory.

While a request is open, it carries a ceremony link. The agent passes it to the person who should sign, copied exactly as Hadron gave it; it never builds one itself. The link has no token in it. Opening it is not enough: the page still asks for your passkey. Once the request has ended, there is no link to open.

A request ends exactly once, in one of five ways:

Ending What happened
Completed The person signed, and the signature verified.
Declined The person who could sign turned it down.
Expired Nobody signed in time. A request lasts 24 hours unless your deployment sets a different lifetime.
Stale The node's title, abstract or content changed before anyone signed, or its memory was encrypted. The person would have been signing text the node no longer says.
Withdrawn The account that asked took it back. Any of that account's sessions or workers can withdraw it.

Ended requests are kept, so the node's history shows who asked, when, and how each request ended.

Some nodes can't be signed at all:

  • Comments, which are feedback beside a node rather than part of it (see Comments).
  • Placeholders, which have nothing to sign yet.
  • Nodes in an encrypted memory. A signature has to commit to the readable text, which is exactly what an encrypted memory withholds.

Reading a signature

Every signature on a node reads as one of these states. The state is worked out on every read, from the stored signature's verification (reused for the same unchanged record), the current content and the passkey's current state, rather than from a flag set once.

State Meaning Counts?
Current It verifies, and the title, abstract and content haven't changed since it was made. Yes
Pending It was made with the signer's first passkey while that passkey's cooling-off window was still open. It counts once the window ends normally. Not yet
Earlier It verifies, but the text has changed since. No
Cancelled It was made with a first passkey that was revoked inside its window. Never
Not applicable The node is in an encrypted memory, where signing doesn't apply. Signing is refused in an encrypted memory (encrypted_memory_not_applicable in the MCP tools reference), so this appears only on a node that was signed before its memory was encrypted. No

The cooling-off window covers the weakest moment, when someone else might register a first passkey in your name. Its length (at least 72 hours; a server may set it longer) is on the sign-in page. Until the window ends, that passkey's signatures don't count, so there's time to cancel it before anything it signed is believed.

Two more things show up beside the states:

  • A revoked passkey. If the signer revokes their passkey later, their signatures keep their state, and the record shows when the passkey was revoked.
  • Integrity problems. A stored signature that fails re-verification is never shown as a signature. It's counted separately as an integrity problem, so a reader knows something is wrong without mistaking it for someone's confirmation. A completed request whose signature no longer verifies also loses its Signature: line (the request's own line, not the node read's Signatures: line).

A signature shows only the signer and the label they gave their passkey, never the passkey itself.

Signing from a second device

A passkey made on one device does not appear on another by itself. It reaches a second device only through your own passkey provider (iCloud Keychain, 1Password, Google Password Manager and others), and only if that provider syncs there. Someone who keeps their passkeys in a third-party manager often has iCloud Keychain sync switched off, so a passkey made on a Mac may never reach their phone. That is an ordinary setup, not a fault.

To sign from a device that does not have your passkey, use one of these:

  • the same provider on both devices, with sync on;
  • a cross-device QR code (hybrid): your browser or operating system lets a phone that holds the passkey approve on the device you are using;
  • a hardware security key.

Which of these appear is decided by your browser and operating system's passkey prompt, not by Hadron.