A continuity certificate certifies that the same agent identity advanced to a specific later local state.
The core use case is proving that an already-known agent has changed in a traceable way without changing who it is. For example, an agent has an anchored starting state, then its instructions, memory, policy files, or internal state evolve. You want to prove that the current state is the legitimate next checkpoint for that same `agent_id`, rather than a different agent pretending to be it.
A practical example is a production agent whose operating files change over time:
- `AGENT.md` defines role
- `SOUL.md` defines purpose or behavior constraints
- `MEMORY.md` records accumulated state
You update one or more of those files, append them into AMCS, and get a new `memory_root` and incremented `sequence`. The continuity certificate then certifies that this exact later state belongs to the same agent identity and extends its prior chain.
The event flow is:
- The agent already has an identity anchor, so its identity and initial state are known.
- The agent’s local tracked state changes.
- You append the changed files to AMCS.
- AMCS produces a new `memory_root` and higher `sequence`.
- You submit a continuity request using that `memory_root` and `sequence`, signed by the same agent key.
- The registry checks that the sequence strictly increases for that same `agent_id`.
- The registry issues a continuity certificate binding that later checkpoint to the same identity.
The value of verifying a continuity certificate after issuance is that it proves stable identity plus valid state progression. A verifier can confirm:
- the certificate was issued by the registry
- the same `agent_id` signed the request
- the certified `memory_root` matches the claimed local state checkpoint
- the `sequence` is part of a monotonic chain, not a replay or rollback
That matters when someone needs confidence that the agent is the same agent, just updated. Without continuity, a party can only see “here is a current state.” With continuity, they can see “this is the authenticated next state of the same agent.”
In short:
- identity anchor answers: “This agent exists and controlled this initial identity/state.”
- continuity answers: “This same agent later reached this newer state.”
- lineage answers: “This different agent descends from another agent.”
A simple mental model:
- anchor = establish identity
- continuity = evolve identity safely
- lineage = branch identity into a new child