Agent Receipts

Agent Receipts

Your agent says it's done. Prove it.

Agent Receipts gives the work your AI agent does a signed receipt: what went in, what came out, which model ran, how long it took and what it cost. Each receipt is signed with Ed25519 and linked to the one before it, so anyone can check it offline with your public key, without trusting you, your server or the agent. Change one byte and it no longer verifies.

claude mcp add agent-receipts -- npx @agent-receipts/mcp-server

receipts.webaes.com (what it is, install, and a page that signs itself) · demo.receipts.webaes.com (the dashboard with sample data) · verify.webaes.com (a real issuer's verify page) · by Webaes

[Live Demo] [Interactive Walkthrough] [npm version] [License: MIT]

Automatic receipts · Get started · Magic Folder · Memory · How it's different

Automatic receipts

Get a signed receipt for everything your agent does, without changing how you work.

Claude Code: one command. Every file edit, file write, notebook edit and shell command gets its own signed receipt, chained per session, and the session ends with a summary (actions, files touched, duration):

npx @agent-receipts/cli hooks install            # or --scope project / --scope local

It shows the change to Claude Code's settings.json and asks first; hooks uninstall takes it out again. Or install it as a Claude Code plugin:

claude plugin marketplace add webaesbyamin/agent-receiptsclaude plugin install agent-receipts@agent-receipts

Any MCP server: the proxy. Put it in front of a stdio MCP server and every tool call through it is signed (mcp.<server>.<tool>), while every message passes through unchanged:

claude mcp add fs-receipted -- npx -y @agent-receipts/cli proxy --name fs -- npx -y @modelcontextprotocol/server-filesystem ~/Documents

Receipts hold hashes only (inputs, outputs, and each changed file), never commands, file contents or results. See them in the dashboard's Sessions view (npx @agent-receipts/dashboard) or check one with agent-receipts verify-chain <session id>. Setup for Claude Desktop and Cursor: CLI README.

What these receipts do and don't prove:

• They prove what Claude Code (or the MCP client) reported, signed outside the agent. The hook and the proxy run as separate processes, and each receipt is signed the moment the tool finishes, so the agent can't edit a receipt afterwards without breaking it. They don't prove the work was right, only what was done and that the record hasn't changed.
• claude -p can stop the last one. In a scripted run, Claude Code stops background hooks still running when the run ends, so a tool call in the last moment of a run can go unrecorded.
• The computer's owner controls the keys. Receipts are signed with keys in ~/.agent-receipts on your machine. They show the record wasn't changed after signing; someone who controls that machine could sign a false one. To show others, publish your public key so they know which key to trust.
• stdio MCP servers only for now. Remote (HTTP) MCP servers aren't covered yet.

Proof

Every memory observation and every action your agent tracks produces a receipt — a signed JSON document with:

• Ed25519 signature over every field (receipt format v2) — tamper-proof, independently verifiable
• Input/output hashes — proves exactly what went in and came out (raw data never stored)
• Timestamps — when it happened, when it completed
• Agent ID — which agent did it
• Link to the previous receipt — the hash of the one before it, so a missing receipt shows
• Provenance chain — trace any memory back to the conversation that created it

This isn't logging. Logs are mutable text files the agent writes about itself. Receipts are cryptographic proof that a third party can verify without trusting you, your server, or the agent.

Everything runs locally

npx @agent-receipts/mcp-server

That's it. No API key. No account. No cloud. No monthly fee. No data leaving your machine. SQLite database in ~/.agent-receipts/. Works offline. Needs Node.js 22.16 or later.

Get Started

Needs Node.js 22.16 or later.

1. Add the MCP Server

Claude Code:

claude mcp add agent-receipts -- npx @agent-receipts/mcp-server

Claude Desktop (claude_desktop_config.json) / Cursor (.cursor/mcp.json):

{  "mcpServers": {    "agent-receipts": {      "command": "npx",      "args": ["@agent-receipts/mcp-server"]    }  }}

2. Add the System Prompt

This tells your agent when to observe memories, recall context, and track actions — so it works automatically:

npx @agent-receipts/cli prompts claude-code

Copy the output into your project instructions or system prompt.

3. Start Using It

Your agent will now:

• Call memory_context at the start of sessions to load what it knows about you
• Call memory_observe when it learns something worth remembering
• Call track_action when it performs significant actions
• Sign everything with Ed25519

4. See What's Happening

npx @agent-receipts/dashboard    # Web UI at localhost:3274npx @agent-receipts/cli stats    # Terminal overviewnpx @agent-receipts/cli memory entities  # See what your agent remembers

5. Try Before Installing

Run the interactive demo → — experience memory, verification, and bundle export in 60 seconds. No install required.

Magic Folder: receipts for people who don't code

Drop a file into a folder named after a job ("Write product descriptions", "Fix typos"). An agent does the work, and the result comes back in Done/ with your untouched original and a one-page receipt.html that anyone can check, plus an approval step for anything client-facing.

npm install -g @agent-receipts/magic-foldermagic-folder init ~/"Magic Folder"magic-folder run ~/"Magic Folder" --engine ollama --issuer "Your Studio"

Needs Node 22.16 or later and, for free local jobs, Ollama. Step-by-step for Mac, Windows and Linux: receipts.webaes.com/install.

The runner writes the receipt, not the agent: it hashes the real files and records the model, time and cost itself (on Claude, the cost is the Agent SDK's own estimate and is marked as one; on Ollama it's $0). See packages/magic-folder and the static verify page.

Memory

Your agent gets structured, persistent memory across sessions — people, projects, tools, preferences, facts. Not a flat key-value store. An entity-observation graph where every fact links to the conversation that created it.

# Your agent learns somethingmemory_observe → "User prefers TypeScript, uses Neovim, building a SaaS called ModQuote"
# Next session, it already knowsmemory_context → loads everything: entities, observations, relationships, preferences
# You can search itmemory_recall → "what tech stack does the user prefer?" → structured results
# You can forget (and the forget itself is tracked)memory_forget → soft delete with audit trail

The agent handles this automatically when you add the system prompt. You don't manage memory manually.

Portable memory bundles

Export your agent's entire memory as a single verifiable file:

npx @agent-receipts/cli memory export > my-project.bundle.json

The bundle includes every entity, observation, relationship, the receipts that created them, and the public key needed to verify everything. Hand it to another agent, another team, or another Agent Receipts instance — they can verify every fact without trusting you.

The Problem

You're building with AI agents. Claude Code refactors your auth module and says "done, all tests pass." Your agent generates a customer quote and says it applied the right pricing. Your assistant remembers your preferences from last week — but you can't see why it thinks that, or whether it's right.

Three things are broken:

1. Agents forget everything between sessions. Every conversation starts from zero. Context is lost. You re-explain the same things.

2. When agents do remember, you can't see inside. Platform memory is a black box. You can't see what it stored, when, or why. You can't correct it, export it, or verify it.

3. There's no proof of what agents actually did. Logs are mutable. Agents write their own logs. "I updated 3 files and all tests pass" — did it? You're trusting the agent's word about its own work.

Why This Exists

The idea came from building ModQuote, a multi-tenant SaaS for automotive protection and detailing shops: PPF, ceramic coatings, window tint.

AI-drafted quotes are on ModQuote's roadmap, and designing that feature raised a question I couldn't answer with the tools I had. If an agent drafts a $2,400 PPF quote and the customer disputes the price, how do I show what vehicle data it received and which pricing rules it applied? Not with a log entry the agent wrote about itself, but with proof that someone outside my system can check.

Memory tools could tell me what an agent remembered, and observability tools could tell me what happened inside my own pipeline. Neither gave me a record that a customer, a client or an auditor could verify without trusting me.

So I built Agent Receipts first, as its own open-source project. When AI quoting ships in ModQuote, every quote will come with a signed receipt. Until then, Agent Receipts stands on its own: any agent, any client, any workflow.

How It's Different

Most AI tooling answers one of two questions. Memory tools answer "What does my agent remember?" Observability tools answer "What happened in my pipeline?" Agent Receipts answers a third: "Can you prove it?"

• Proof, not logs. Every receipt is signed with Ed25519 over every field (format v2). Logs can be edited and are written by the agent about itself; a receipt breaks if anything changes.
• Anyone can verify it. Offline, in a browser, from the CLI or in code, with a public key. No account, no server, no trusting the person who sent it.
• History you can't quietly rewrite. Receipts link to the one before them, and verify-chain detects edited, removed or forked receipts.
• Memory with provenance. Every fact your agent remembers links to the receipt that created it, and can be exported as a bundle someone else can verify.
• Local-first and free. npx and done. Keys and receipts stay in ~/.agent-receipts. MIT licensed.

What's Inside

• Automatic receipts — Claude Code hooks (and a plugin) and an MCP proxy that sign every action as it happens
• 24 MCP tools — memory, actions, verification, constraints, judgments, invoicing, bundles
• 21 SDK methods — full TypeScript API
• 17 CLI commands + 9 memory and 3 hooks subcommands — terminal-first
• 20 dashboard pages — receipts, sessions, memory graph, chains, agents, constraints, judgments, invoices
• 714 tests (697 across the packages, 17 for the website) — zero TypeScript any in package source
• Ed25519 + SHA-256 — via @noble/ed25519 (pure JS, no native code); receipt format v2 signs every field
• SQLite + FTS5 — Node's built-in SQLite, local-first with full-text memory search; no native modules to install

Links

~/.agent-receipts/├── keys/│   ├── private.key    # Ed25519 private key (mode 0600)│   └── public.key     # Ed25519 public key├── receipts.db        # SQLite database (receipts + memory)└── config.json        # Agent and org configuration

Packages

All MIT, all on npm. Node.js 22.16 or later, using its built-in SQLite. (Node 22, and 24 before 24.15, call built-in SQLite experimental; Agent Receipts hides that one notice.)

Roadmap

• Cloud tier — team dashboards, multi-agent memory sync, cross-org verification
• Semantic recall — embedding-powered memory search
• Framework adapters — LangChain, CrewAI, AutoGen integrations
• Cross-org trust bridges — two organizations verifying each other's agent receipts

License

MIT

Built by Amin Suleiman — building ModQuote and Agent Receipts.