01 / 08 · COVER

ἀλήθεια

alethech

verifiable agent continuity protocol

230 tests· 8 mutation paths· v0.7.0· MIT

github ↗ pypi ↗

02 / 08 · WHAT IS ALETHECH

what is alethech

definition + the property

alethech is a Python package that provides cryptographically verifiable memory continuity for AI agents.

It lets an agent sign its memory commits with Ed25519, link them in a Merkle DAG, rotate keys without losing identity, and prove to a third party that its memory was not tampered with.

The protocol does NOT prove that the agent's claims are true — only that they were signed by the identity that claims them.

the protocol does NOT prove claims are true — only that they were signed.

03 / 08 · HOW IT WORKS

how it works

dag + six steps

provenance edge rejected ancestry cutoff_head

alethech init generates an Ed25519 keypair + identity derived from public key
alethech commit --content memory.json signs the content + links to DAG parent
alethech verify checks signatures, DAG integrity, identity binding, reachability
alethech key rotate revokes old key with cutoff_head, grants new key, both signed by root
alethech export --output dir/ creates portable signed bundle
alethech import --input dir/ verifies bundle + writes atomically (target untouched on failure)

read the graph D dangles off C2 but sits past the cutoff — its ancestry is not proven, so it is rejected. C3 is signed under key-002 and still reaches back through the cutoff_head, so it is valid. The cutoff_head is the causal frontier at the moment of key rotation — not a timestamp, but a commit hash. Workflow: init once, commit per memory delta, verify on demand, rotate when a key is compromised or aged out. Import verifies the entire bundle before writing a single byte — failure leaves the target untouched.

04 / 08 · MATH + GUARANTEES

the math + the guarantees

equations, then the checklist

commit_id = sha256(JCS(object − {commit_id, signature}))

content-addressed id over the canonicalized object, with the id and signature fields removed.

signature = Ed25519_sk(JCS(object + commit_id))

deterministic Ed25519 signature over the canonical object plus its freshly computed commit_id.

agent_id = did:alethech: + b32(sha256(JCS(pk))[:16])

identity derives from the root public key — operational keys rotate, the agent_id does not.

C ∈ ancestry(cutoff_head) ⟹ VALID_HISTORICAL

a commit is valid iff its ancestry is reachable from the last pre-rotation head.

the guarantees · ✓ does · ✗ does not

✓signature verifies against declared public key
✓commit_id matches SHA-256 of canonical JSON
✓agent_id derives from public key (not declared)
✓key rotation preserves identity (root-bound)
✓revoked key commits checked against ancestry(cutoff_head)
✓checkpoint head must be ancestor of current HEAD
✓import is atomic (verify-then-write, target untouched on failure)
✗does NOT prove content truth
✗does NOT encrypt at rest
✗does NOT detect rollback without external checkpoint
✗does NOT delegate permissions between agents
✗does NOT call any LLM

05 / 08 · VERDICTS · ROTATION · ROLLBACK

verdicts, rotation, rollback

three faces of one cutoff

verdict VALID_HISTORICAL C ∈ ancestry(cutoff_head)

verdict NOT_IN_PROVEN_PRE_ROTATION_HISTORY C ∉ ancestry(cutoff_head)

critical: the verifier does NOT claim to prove WHEN the commit was created — only that it is reachable from a verified head. Membership, not timing.

key rotation — revoke the key, keep the identity

key-001 revoked

cutoff_head

key-002 active

agent_id derives from the root, not the operational key. Keys can be revoked and replaced; the identity they attest to does not move. Revocation is permanent and visible — a struck key still exists in the DAG as a historical signer, but no post-cutoff commit signed by it is accepted.

anti-rollback — sequence is the authority

forward monotonic sequence — accepted:

10→ 11→ 12→ 13→ 14→ 15 [ ACCEPTED ]

stale sequence — rejected as rollback:

5 [ REJECTED — rollback ]

the system clock is NOT the authority — sequence is. Time lies; monotonic counters cannot be wound back without breaking the chain. Two commits cannot share a sequence number; the counter only moves forward.

06 / 08 · LIVE TERMINAL

try it — real crypto in your browser

live terminal

the loop, typed live when this section enters view: init → commit → rotate → verify.

alethech — interactive terminal real crypto · web crypto api · ed25519

↳ live from github.com/eddyflores100-lang/alethech

$

type 'help' or 'alethech init' to begin · arrow keys navigate history

this is real Ed25519 + SHA-256 + JCS, running in your browser via Web Crypto API No backend, no simulation. Every command runs actual cryptography — real Ed25519 keypairs, real SHA-256 commits, real signature verification. Click the terminal and type. Export a bundle, paste it back into alethech import, and watch the verifier check every signature from public keys alone.

07 / 08 · HONESTY + STATS

honesty + stats

what it refuses + the numbers

what it does NOT do

NOT · prove truth
NOT · rollback without checkpoint
NOT · encrypt at rest
NOT · delegate permissions
NOT · call any LLM
NOT · prove physical time

by the numbers

230: tests passing
8: mutation-guard paths
56: JCS conformance vectors
15: adversarial conformance vectors
9: CLI commands
4: cryptographic primitives (Ed25519, SHA-256, JCS, base32)
0: open issues
1: branch (main)
MIT: license
0.7.0: current version