ChainProof is an audit ledger for AI agent workflows. Your agent reports what it does; ChainProof appends those reports to an append-only, SHA-256 hash-chained log. Any post-hoc edit to a past entry shifts every downstream hash, making tampering detectable by anyone who recorded the chain head at write time.

What is agent provenance?

Agent provenance is a verifiable record of what an AI agent did during a task — which tools it called, what decisions it made, what inputs it received, and what outputs it produced. ChainProof records this as a hash-chained ledger, so the history can be verified later and tampering is detectable.

How does ChainProof's hash chain work?

Each ledger entry includes SHA-256(all entry fields + previous entry hash). The first entry uses a genesis hash of 64 zeros. The final hash after all entries is the run's chain head. To verify, recompute the chain from entry 0 — if your result matches the stored head, nothing changed. You can do this independently without trusting ChainProof's own verify endpoint.

Does ChainProof watch or monitor my AI agents?

No. ChainProof does not intercept, monitor, or independently observe your agents. Your agent code explicitly calls the API to append each entry. ChainProof records exactly what the agent reports — it cannot verify whether those reports are accurate.

How do I integrate ChainProof with my AI agent?

Three API calls: POST /v1/runs to open a run, POST /v1/runs/:id/entries for each action or event (with the previous entry hash for chain linking), and POST /v1/runs/:id/complete when done. No SDK required — works with any HTTP client. A TypeScript SDK is in development.

Yes. The free tier includes 500 runs per month, 50,000 ledger entries, and 100 chain verifications at no cost. No credit card required. Paid plans start at $49/month for production use.

// AGENT PROVENANCE PLATFORM

Every AI action.
Logged. Chained. Verifiable.

Your agents report what they did. Every entry is SHA-256 hashed against the previous. If you record the chain head, you can verify later whether anything changed. Any edit to a past entry produces a different head — detectable by anyone who checks.

Start free See how it works

agent.ts

const BASE = "https://api.chainproof.ai/v1";
const h = { "Authorization": "Bearer cp_live_…", "Content-Type": "application/json" };

// 1. start a chain
const { chain_id } = await fetch(`${BASE}/chains`, {
  method: "POST", headers: h,
  body: JSON.stringify({ agent_id: "agt_summarizer", trust_level: "high" }),
}).then(r => r.json());

// 2. log an action
await fetch(`${BASE}/chains/${chain_id}/entries`, {
  method: "POST", headers: h,
  body: JSON.stringify({ entry_type: "action", action: { tool: "read_file", status: "completed" } }),
});

// 3. verify chain integrity
const proof = await fetch(`${BASE}/chains/${chain_id}/verify`, { headers: h }).then(r => r.json());
// → { valid: true, entry_count: 1 }

// HOW IT WORKS

Your agent writes the log. The chain makes edits detectable.

ChainProof wraps around your agent's existing workflow. No SDK required — plain HTTP and a Bearer token.

Start a chain

Each agent execution gets its own chain. Your agent tells ChainProof what it's doing — the trust level, the instruction, the agent ID. ChainProof records that claim and opens the ledger.

POST /v1/chains → { chain_id, chain_head }

Agent reports each action

As your agent works, it appends entries — actions, decisions, tool calls, human approvals. Each entry is SHA-256 hashed against the previous. ChainProof records exactly what the agent said it did.

POST /v1/chains/:id/entries → { entry_hash }

Prove the log is unaltered

Chain verification doesn't tell you whether the agent succeeded. It tells you whether the log was touched after the fact. A broken link means an entry was modified post-commit — not that a task failed.

GET /v1/chains/:id/verify → { valid: true }

// WHAT CHAINPROOF PROVES

A notary, not a watchdog.

ChainProof only knows what your agent tells it. That's not a limitation — it's the design. An external system that claims to independently verify agent behavior is guessing. ChainProof makes a narrower, harder guarantee.

✓ What ChainProof gives you

A structured, queryable record of what your agents reported doing.

A hash chain you can recompute yourself — you don't have to trust our verify endpoint.

Detection of post-hoc edits, if you record chain heads independently at write time.

Content hashes for artifacts — if the hash matches, the payload hasn't changed.

✗ What ChainProof doesn't give you

Independent verification that agents told the truth.

A guarantee that ChainProof itself hasn't altered records — only external anchoring would provide that.

Any signal about whether a chain's task succeeded at its real-world goal.

Protection against an agent that deliberately logs false entries.

Chain validity and chain status are independent signals. status: failed with a valid chain means the agent reported failure and nothing in the log changed since. status: completed with a broken chain means an entry was edited after it was written — by someone, somewhere. ChainProof can tell you the second happened. It can't tell you who did it or why.

// QUICKSTART

The full lifecycle in one file.

Bootstrap a tenant, register an agent, run the full provenance cycle. No SDK needed — works with fetch, curl, or any HTTP client.

TypeScript

cURL

const BASE = "https://api.chainproof.ai/v1";
const headers = {
  "Authorization": `Bearer ${process.env.CHAINPROOF_API_KEY}`,
  "Content-Type": "application/json",
};

// 1 ── register an agent
const agent = await fetch(`${BASE}/agents`, {
  method: "POST", headers,
  body: JSON.stringify({ name: "summarizer", trust_level: "high" }),
}).then(r => r.json());

// 2 ── start a chain
const chain = await fetch(`${BASE}/chains`, {
  method: "POST", headers,
  body: JSON.stringify({ agent_id: agent.agent_id, trust_level: "high" }),
}).then(r => r.json());
// → { chain_id: "ba7d...", chain_head: "0000...genesis" }

// 3 ── append a ledger entry
const entry = await fetch(`${BASE}/chains/${chain.chain_id}/entries`, {
  method: "POST", headers,
  body: JSON.stringify({
    entry_type: "action",
    previous_entry_hash: chain.chain_head,
    action: { tool: "read_file", status: "completed" },
  }),
}).then(r => r.json());
// → { sequence: 0, entry_hash: "c1f9..." }

// 4 ── complete the chain
await fetch(`${BASE}/chains/${chain.chain_id}/complete`, {
  method: "POST", headers,
  body: JSON.stringify({ status: "completed" }),
});

// 5 ── verify the chain
const proof = await fetch(`${BASE}/chains/${chain.chain_id}/verify`, { headers })
  .then(r => r.json());
// → { valid: true, entry_count: 1, chain_head: "c1f9..." }

export BASE="https://api.chainproof.ai/v1"
export KEY="cp_live_…"

# 1 ── register an agent
agent=$(curl -sX POST "$BASE/agents" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"summarizer","trust_level":"high"}')
AGENT_ID=$(echo $agent | grep -o '"agent_id":"[^"]*"' | cut -d'"' -f4)

# 2 ── start a chain
chain=$(curl -sX POST "$BASE/chains" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d "{\"agent_id\":\"$AGENT_ID\",\"trust_level\":\"high\"}")
CHAIN_ID=$(echo $chain | grep -o '"chain_id":"[^"]*"' | cut -d'"' -f4)
CHAIN_HEAD=$(echo $chain | grep -o '"chain_head":"[^"]*"' | cut -d'"' -f4)
# → { "chain_id": "ba7d...", "chain_head": "0000...genesis" }

# 3 ── append a ledger entry
curl -sX POST "$BASE/chains/$CHAIN_ID/entries" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d "{\"entry_type\":\"action\",\"previous_entry_hash\":\"$CHAIN_HEAD\",\"action\":{\"tool\":\"read_file\",\"status\":\"completed\"}}"
# → { "sequence": 0, "entry_hash": "c1f9..." }

# 4 ── complete the chain
curl -sX POST "$BASE/chains/$CHAIN_ID/complete" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{"status":"completed"}'

# 5 ── verify the chain
curl -s "$BASE/chains/$CHAIN_ID/verify" \
  -H "Authorization: Bearer $KEY"
# → { "valid": true, "entry_count": 1, "chain_head": "c1f9..." }

Every AI action.
Logged. Chained. Verifiable.

Your agent writes the log. The chain makes edits detectable.

Everything you need to know.

A notary, not a watchdog.

The full lifecycle in one file.

Your agents are running.
Is there a record?

Every AI action.Logged. Chained. Verifiable.

Your agent writes the log. The chain makes edits detectable.

Everything you need to know.

A notary, not a watchdog.

The full lifecycle in one file.

Your agents are running.Is there a record?

Every AI action.
Logged. Chained. Verifiable.

Your agents are running.
Is there a record?