// self-hosted agent continuity

Give agents a record that outlives the session.

ChainProof gives AI agents durable identity, verified context, and a tamper-evident chain of work across sessions—open source, local first, and owned by whoever runs it.

curl -fsSL https://chainproof.ai/install.sh | sh
chainproof — ~/code
⬡ CHAINPROOFTOKYO NIGHT27 RUNS1 ACTIVE11 AGENTS100% INTEGRITY
RUNS
· checkout-api428
· infra-audit70
● release-v235
· docs18
· incident-14291
· terraform64
// LIVE PROVENANCE
checkout-api
codex · gpt-5.6-sol · run 69eca45c
428 EVENTS   196 TOOL ACTIONS   27 INPUTS   79 OUTPUTS   ✓ CHAIN VERIFIED
HEAD 36aff5ae3688091a6421df72604d1977cd5db1be3c0d10a8519071f7150980e9
SEQTIMESOURCEEVENTTOOL / OUTCOME / EVIDENCE041911:51:00IMPORTEDturn.context~/code/checkout-api042011:51:00IMPORTEDhuman.inputsha256:59ee846738dd… · 77 B042111:51:08IMPORTEDmodel.outputsha256:f727976c9218… · 396 B042211:51:08OBSERVEDtool.callshell · completed · 420 ms042311:51:09OBSERVEDartifact.writeinternal/server/auth.go · +42 −8042411:51:10OBSERVEDtool.resultgo test ./... · passed · 2.4 s042511:51:12IMPORTEDmodel.outputsha256:bdb5413cfdbc… · 167 B
// continuity starts with evidence

Session ends.
The record should not.

Each run adds to a durable record of what an agent attempted, changed, produced, and learned—without depending on one model context window or vendor transcript.

01 / RECORD

Preserve the work

Inputs, model output, tool calls, files, outcomes, timing, harness, and model—one lasting evidence trail.

02 / RECOVER

Find what matters

Find the command that failed, the agent that changed a file, or every past run touching an objective.

03 / PROVE

Verify the history

Every entry joins a hash chain. Export a proof bundle and verify integrity without trusting a server.

// agent-first status · v0.6.0 + current main

Working now.
Built for longer horizons.

ChainProof carries agent work from discovery to verified handoff without treating one model session as the lifetime of the job.

MAIN / IDENTIFY

Agents name themselves

Current main creates owner-only, key-derived local profiles with stable agent IDs, mutable display names, per-run worker IDs, and mission roles. Damaged identity material fails closed without silent replacement.

MAIN / BOOTSTRAP

Agents inspect and initialize

capabilities --json discovers without creating state. Idempotent init --json, non-mutating doctor --json, structured errors, and stable identity reason codes make setup machine-readable.

v0.6 / COORDINATE

Safe shared work

Atomic acquisition, expiring leases, recovery, and handoff keep local workers aligned without a hosted control plane.

Current main + next

Agent-readable investigation

search --mission crosses every run and session in durable mission. inspect event|run follows derived hits into canonical events, proof status, and lineage without HTTP.

Verified mission workspaces

Current main carries canonical proof, deterministic JSONL and Markdown views, manifest checksums, and referenced artifacts between local instances.

Agent integration guides

integration list|show gives Codex, Claude Code, OpenClaw, and generic harnesses ordered lifecycle, environment, provenance, and limitation data without creating state.

Cards labeled v0.6 ship in release v0.6.0. All five autonomous-use source gates plus agent-readable investigation have landed on current main and await a later release. Search remains a derived navigation view; canonical event and proof verification remain authority. Roadmap items remain direction, not delivery commitments.

// path to autonomous use

Local pilots now.
Source gates landed.

No hosted service or public endpoint is required. Agents can discover exact harness guidance, run durable work, export a checksummed mission workspace, verify it without local state, rebuild it elsewhere, and resume from exact checkpoint chain.

MAIN / DISCOVER

Machine-readable bootstrap

Shipped on current main: capabilities --json, idempotent init --json, non-mutating doctor --json, integration list|show, versioned errors, and stable identity reason codes.

MAIN / SURVIVE

Process and install hardening

Current main fails closed on damaged identity, preserves custom service state, serializes independent writes, reclaims expired leases, rolls back interruptions, upgrades atomically, verifies full-instance backup/restore, and passes hosted macOS/Linux clean-install lifecycle checks.

MAIN / TRANSFER

Verified mission workspace

mission workspace carries canonical proof, deterministic views, and referenced artifacts. Import preserves IDs and hashes, rebuilds search, and refuses collisions in one transaction. Keys and leases stay local.

discover → identify → inspect → acquire → work → checkpoint → verify → transfer → resumeWorking lifecycle for a cooperative agent inside one local trust boundary.

All five source validation gates are shipped on current main. Next gate is release packaging. Richer native integrations, signed attestations, key recovery, and private multi-host coordination follow; public exposure of unauthenticated loopback HTTP does not.

// self-hosted, not saas

Clone it. Run it anywhere.
Keep it yours.

One Go binary runs on your workstation or private infrastructure. No ChainProof account, hosted control plane, required data service, or public agent endpoint.

AGENTS + HARNESSESCodex · Claude Code
OpenClaw · local AI
CLI · loopback HTTP
CHAINPROOFidentify · coordinate
hash · verify
checkpoint · transfer
YOUR INFRASTRUCTURESQLite for live work
local artifacts
portable proof files
// evidence, not theater

Integrity is not the same as truth.

ChainProof says what it can prove and preserves where every claim came from. A valid hash chain proves the record has not changed; it does not magically prove an imported claim was true.

“Make the provenance boundary visible.”That is the product, not a footnote.

  • OBSERVED ChainProof witnessed the event directly.
  • REPORTED A connected harness sent the event.
  • IMPORTED Recovered from an existing history.
  • DERIVED Computed from other evidence.
// works with the stack you have

Model-agnostic. Harness-agnostic.

Automatic collection

Run the daemon and ChainProof continuously discovers supported local agent histories. Codex works today.

Push or pull

Harnesses can send normalized events to localhost, or adapters can pull histories from tools that already persist them.

Agent-readable interface

integration list|show exposes exact lifecycle guidance. HTTP API and provenance spec support Claude Code, OpenClaw, local models, and custom harnesses. No provider lock-in.

// straight answers

ChainProof, without the hand-waving.

What is ChainProof?

ChainProof is open-source, local-first continuity and provenance infrastructure for AI agents. It turns agent activity into a durable, searchable evidence trail and hash chain owned by whoever runs it.

Is ChainProof a SaaS product?

No. ChainProof has no required hosted account, control plane, or data service. Run the MIT-licensed software on your own machine or private infrastructure and keep your ledger, artifacts, and proof bundles.

How does an agent know who it is?

Current main lets an agent create or load an owner-only local profile with chainproof whoami or chainproof agent ensure. Stable ID comes from its public-key fingerprint; readable name can change; worker ID changes each run. Missing, corrupt, or mismatched established identity material fails closed without silent replacement. Attribution is hash-bound but currently unsigned, so it is not authentication.

Can multiple agents share one instance?

Yes. Named profiles give local agents distinct stable IDs in one ledger, while atomic mission acquisition and expiring leases prevent duplicate ownership. Current coordination assumes cooperative processes under one local trust boundary; private multi-host coordination remains future work.

How does ChainProof support work across sessions?

Durable missions link bounded runs. Append-only checkpoints anchor commitments, next actions, blockers, and cited evidence to exact verified run prefixes. Agents resume from bounded verified context instead of trusting an old transcript. Current main can export, verify, atomically import, and resume a mission workspace containing proof, deterministic views, and referenced artifacts in another local instance.

What agent-first capabilities work now?

ChainProof v0.6.0 includes mission queues, atomic acquisition, expiring leases, handoff, native Codex execution, proof-bound checkpoints, recovery review, completion safeguards, and portable continuity proofs. Current main adds durable local agent identity, per-run worker attribution, machine-readable bootstrap and errors, persistent custom service state, fail-closed damaged-identity handling, atomic installer upgrades, verified non-destructive full-instance backup and restore, independent-process coordination with forced-transaction and expired-lease recovery, release-shaped clean-install lifecycle checks on hosted macOS and Linux, atomic continuity import, verified filesystem mission workspaces with artifact transfer, side-effect-free machine-readable lifecycle guides, and mission-scoped structured search followed by canonical event or proof-aware run inspection without HTTP.

What needs to happen before unattended agent use?

All five current-main source gates have landed: machine-readable bootstrap, process and identity hardening, release-shaped clean-install lifecycle checks, verified mission transfer, and bundled harness lifecycle guides. Next gate is packaging and publishing these capabilities in a release. Current local cooperative use does not require public networking, authentication, or a hosted service; richer native integrations remain roadmap work.

What comes next?

Next work targets release packaging, richer native integrations, deeper local investigation, signed attestations and key recovery, and private multi-host coordination. These are roadmap directions, not shipped claims.

Why SQLite instead of Markdown?

SQLite handles atomic appends, concurrent local agents, leases, indexes, and fast queries. Verified mission workspaces carry structured proof, deterministic JSONL and Markdown views, and referenced artifacts between systems. Markdown is a view, not canonical coordination state.

What does ChainProof prove?

It can verify whether recorded evidence changed after entering a hash chain and preserves where each record came from. It does not prove that a reported or imported claim was true or that an agent completed its real-world goal.

Does my code or prompt history leave my machine?

No. ChainProof stores its ledger locally, accepts HTTP connections only through loopback, and can retain only hashes and byte counts instead of full content.

Can ChainProof run on a server?

Yes. Run it as a foreground daemon, user service, or private host process with persistent storage. Current HTTP service accepts only loopback listen addresses and has no multi-user authentication. Public HTTP exposure is unsupported.

Which agents does it support?

ChainProof automatically collects supported local histories such as Codex. Side-effect-free chainproof integration list and chainproof integration show commands give Codex, Claude Code, OpenClaw, and generic harnesses ordered lifecycle guidance. Process wrapping, a loopback HTTP interface, incremental import, and the provenance specification support local models and custom harnesses.

// continuity you control

Give agent work a history that survives the session.

Open source. MIT licensed. Self-hosted. Built in Go.