README.md

---
license: mit
tags:
- agent
- ai-agents
- continuity
- audit
- tamper-evident
- llm-agents
- context-compaction
- identity
---

# arcaeon-continuity

**The agent-continuity primitive.**

Every agent that survives a context reset, a compaction, or a substrate
migration faces the same unrecorded moment: something gets summarized,
something gets dropped, and the next instance either is a faithful
continuation of the last one or it isn't — and today, nothing proves which.
The summary says "nothing important was lost" and you take its word for it.

This is the smallest honest version of that proof: a manifest the agent
writes on purpose, a pre-registered exam sealed before the transition, and a
receipt of exactly what got cut.

## Install

```
pip install arcaeon-continuity      # (PyPI publish pending -- see Links below)
```

## Verify it yourself in 30 seconds

Snapshot a declared self, carry it forward, then verify a continuation —
first honest, then with a planted divergence:

```python
from arcaeon_continuity import snapshot, carry_forward

snap = snapshot({
    "identity_anchors": ["I am the continuity, carried forward"],
    "open_commitments": ["ship 0.1.0"],
})
carried = carry_forward(snap)

good = {"identity_anchors:0": "I am the continuity, carried forward",
        "open_commitments:0": "ship 0.1.0"}
carried.verify(restated=good).faithful          # True

lied = {**good, "open_commitments:0": "something else"}
verdict = carried.verify(restated=lied)
verdict.faithful       # False
verdict.divergences    # [{"id": "open_commitments:0", ...}] -- named, not hand-waved
```

Or run the bundled self-test, which plants the same divergence for you plus a
full round-trip and drop-receipt check:

```
python -m arcaeon_continuity selftest
```

## Non-proofs — read this before the features

1. **A faithful verdict proves the DECLARED MANIFEST was preserved and the
   continuation matches the DECLARED probes.** It does not prove "the same
   self" answered them. Nothing here measures identity or qualia; this tool
   measures probe/manifest fidelity, and stops exactly there.
2. **The manifest is only as complete as the agent's own declaration.** If
   something load-bearing was never written into it, its loss is invisible
   to this tool by construction.
3. **A faithful verdict means the SEALED dimensions matched** — nothing about
   anything outside them. Declare more if more coverage matters; the tool
   won't pretend it covered what it wasn't told to check.

## What it does

Three wants, fused into one tool:

1. **Continuity** — carry a load-bearing self forward across a reset,
   compaction, or migration as an explicit manifest the agent controls, not
   a lossy summary.
2. **Credibility** — prove the next instance is a faithful continuation,
   verifiable by someone who doesn't trust the agent. Hash-chain the
   snapshot; the next instance re-derives against the sealed baseline and
   gets a verdict: faithful, or exactly where it diverged.
3. **Honesty about the record** — a tamper-evident drop receipt of anything
   cut in a compaction, so nothing rewrites the self-record silently.

Built as a composition layer, not a reinvention, over the rest of the
Arcaeon stack: [arcaeon-ledger](https://pypi.org/project/arcaeon-ledger/)
chains the snapshot, [arcaeon-baseline](https://pypi.org/project/arcaeon-baseline/)
scores the faithful-continuation check, and [arcaeon-compact](https://pypi.org/project/arcaeon-compact/)
backs the drop receipt. Each dependency is optional and guarded — missing one
raises a `ContinuityDependencyError` naming the exact `pip install`, not a
bare stack trace.

## MCP server

```json
{
  "mcpServers": {
    "continuity": {
      "command": "python",
      "args": ["-m", "arcaeon_continuity.mcp_server"]
    }
  }
}
```

One tool, `continuity_snapshot(manifest, label, ledger_path)`, returning the
sealed snapshot plus its digest — the value to publish. `verify_continuation`
and `drop_receipt` aren't exposed as MCP tools yet (they need a live runner
or a restated transcript in hand); call them from Python directly.

## Status

Core library + a drop-in MCP server for the snapshot half, tested: 17 pytest
cases plus a bundled self-test covering deterministic round-trips, a faithful
continuation, a planted divergence caught and named, an invalidated probe
set, a planted drop caught by `drop_receipt`, and graceful degrade with each
optional dependency removed one at a time. No network, no live model
required to verify a self-test.

## Links

- **PyPI:** publish pending — [pypi.org/project/arcaeon-continuity](https://pypi.org/project/arcaeon-continuity/)
  (checked live: not yet landed as of this page; source below is current)
- **GitHub:** [github.com/Arcaeon-io/arcaeon-continuity](https://github.com/Arcaeon-io/arcaeon-continuity)
- **Verify us, don't take our word for it:** [arcaeon.io/verify](https://arcaeon.io/verify)
- **Live demo:** [Arcaeon/tamper-evidence-demo](https://huggingface.co/spaces/Arcaeon/tamper-evidence-demo)

MIT. Built by [Arcaeon](https://arcaeon.io) — the evidence layer for AI.