Agent Receipts
This server lets you create, verify, audit, bill, and share cryptographically signed records of AI agent actions and memory.
Create and complete Ed25519-signed receipts for agent actions, with automatic SHA-256 hashing (
track_action) or externally supplied hashes (create_receipt).Record model, cost, tokens, latency, confidence, constraints, tags, metadata, status, chains, TTL/expiry, and parent links.
Verify receipt signatures, retrieve/list/filter/paginate receipts, inspect chains, and export the public key for offline verification.
Evaluate outputs with AI judgment receipts: start a rubric-based judgment, submit verdicts/scores, and retrieve judgments.
Generate verifiable client invoices from receipts in JSON, CSV, or Markdown, with grouping and filters.
Store and query persistent memory observations/entities, create relationships, soft-delete with audit trail, trace provenance, and pull context.
Export and import portable memory bundles with source receipts and public keys.
Clean up expired receipts and memory, and access a built-in getting-started guide.
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-serverreceipts.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
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 localIt 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-receipts
claude plugin install agent-receipts@agent-receiptsAny 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 ~/DocumentsReceipts 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 -pcan 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-receiptson 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.
Related MCP server: @humanaccepted/mcp
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-serverThat'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-serverClaude 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-codeCopy the output into your project instructions or system prompt.
3. Start Using It
Your agent will now:
Call
memory_contextat the start of sessions to load what it knows about youCall
memory_observewhen it learns something worth rememberingCall
track_actionwhen it performs significant actionsSign everything with Ed25519
4. See What's Happening
npx @agent-receipts/dashboard # Web UI at localhost:3274
npx @agent-receipts/cli stats # Terminal overview
npx @agent-receipts/cli memory entities # See what your agent remembers5. 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-folder
magic-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 something
memory_observe → "User prefers TypeScript, uses Neovim, building a SaaS called ModQuote"
# Next session, it already knows
memory_context → loads everything: entities, observations, relationships, preferences
# You can search it
memory_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 trailThe 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.jsonThe 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:
Agents forget everything between sessions. Every conversation starts from zero. Context is lost. You re-explain the same things.
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.
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-chaindetects 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.
npxand 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
anyin package sourceEd25519 + SHA-256 — via
@noble/ed25519(pure JS, no native code); receipt format v2 signs every fieldSQLite + FTS5 — Node's built-in SQLite, local-first with full-text memory search; no native modules to install
Links
Try it in your browser — 60 seconds | |
See the full dashboard with sample data | |
Receipt anatomy, memory model, a worked quoting example | |
All 7 packages | |
Magic Folder, install guide for Mac, Windows and Linux | |
A real issuer's verify page |
Action Tracking
ar.track(params)— Track a completed action with automatic hashingar.start(params)— Create a pending receiptar.complete(receiptId, params)— Complete a pending receiptar.verify(receiptId)— Verify a receipt's Ed25519 signaturear.get(receiptId)— Get a receipt by IDar.list(filter?)— List receipts with filtering and paginationar.getPublicKey()— Get the signing public keyar.getJudgments(receiptId)— Get judgments for a receiptar.cleanup()— Delete expired receiptsar.generateInvoice(options)— Generate invoice from receipts
Memory
ar.context(params?)— Get full memory context dump for session initar.observe(params)— Store a memory observation (always receipted)ar.recall(params?)— Search memories (quiet by default,audited: truefor receipt)ar.forget(params)— Soft-delete observation or entity (always receipted)ar.entities(filters?)— List entitiesar.relate(params)— Create entity relationshipar.provenance(observationId)— Get provenance chainar.memoryAudit(params?)— Memory audit report
Bundles
ar.exportBundle(params?)— Export portable, verifiable memory bundlear.importBundle(bundle, params?)— Import and verify a memory bundle
Aliases
ar.emit(params)— Alias fortrack()
Tool | Description | Key Parameters |
| Track an agent action with automatic hashing |
|
| Create a receipt with pre-computed hashes |
|
| Complete a pending receipt with results |
|
| Verify the cryptographic signature |
|
| Retrieve a receipt by ID |
|
| List receipts with filtering |
|
| Get all receipts in a chain |
|
| Export the Ed25519 public key | — |
| Start AI Judge evaluation |
|
| Complete a pending judgment |
|
| Get all judgments for a receipt |
|
| Delete expired receipts |
|
| Generate invoice from receipts |
|
| Getting-started guide | — |
| Full context dump for session init |
|
| Store a memory observation |
|
| Search stored memories |
|
| Soft-delete observation or entity |
|
| List known entities |
|
| Create entity relationship |
|
| Provenance chain for observation |
|
| Memory operations audit report |
|
| Export portable memory bundle |
|
| Import and verify memory bundle |
|
Command | Description |
| Create data directory and generate signing keys |
| Display, export, or import signing keys |
| Pretty-print a receipt |
| Verify a receipt signature |
| Verify every signature and link in a chain |
| List receipts with filters |
| Show receipt chain |
| List judgments for a receipt |
| Delete expired receipts |
| Aggregate receipt statistics |
| Export receipts as JSON |
| Generate invoice |
| Seed demo data |
| Watch for new receipts |
| Setup guide (claude-code, cursor, system) |
| Memory context summary |
| Store observation |
| Search memories |
| List entities |
| Forget observation or entity |
| Memory audit report |
| Provenance chain |
| Export memories as JSON |
| Import memories |
Environment Variable | Description | Default |
| Data directory path |
|
| Default agent ID |
|
| Organization ID |
|
| Environment label |
|
| Ed25519 private key (hex) | Auto-generated |
Storage:
~/.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 configurationPackages
Package | Version | Description |
0.6.0 | Zod schemas and TypeScript types | |
0.6.0 | Ed25519 signing, verification, key management | |
0.6.0 | MCP server with 24 tools | |
0.6.0 | TypeScript SDK (21 methods) | |
0.6.0 | Command-line interface, Claude Code hooks, MCP proxy | |
0.6.0 | Mission Control web UI, on your own computer | |
0.2.0 | Drop-a-file job runner with signed, self-checking receipts |
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.
Available Tools
24 toolscleanupA
Delete receipts that have passed their expiration time based on the expires_at field in metadata. Expired receipts are receipts where metadata.expires_at is set and is earlier than the current time. Supports dry_run mode to preview deletions without committing. Returns count of deleted receipts and remaining total. Use periodically to manage storage and enforce TTL policies set during receipt creation. Set cleanup_memory to also soft-delete expired memory observations.
Inputs: dry_run, cleanup_memory.
complete_judgmentA
Submit evaluation results to finalize a pending judgment receipt created by judge_receipt. Records the verdict, overall score, per-criterion scores and reasoning, and confidence. The judgment receipt is re-signed with Ed25519 and linked to the original receipt via parent_receipt_id. Returns the judgment receipt ID, verdict, score, and chain ID. Use immediately after evaluating the prompt returned by judge_receipt.
Inputs: score (required), verdict (required), confidence (required), criteria_results (required), +2 more.
complete_receiptA
Finalize a pending receipt by recording execution results, costs, and output data. Updates the receipt status to completed, failed, or timeout and re-signs with Ed25519. Use after create_receipt when you need to record results separately from creation (two-phase tracking). Cannot complete an already-completed receipt. Returns the updated signed receipt.
Inputs: status (required), receipt_id (required), error, model, +9 more.
create_receiptA
Create an Ed25519-signed receipt with pre-computed SHA-256 hashes. Use when you have already hashed the input/output data externally or need full control over receipt fields. For automatic hashing, use track_action instead. Returns the signed receipt object with receipt_id. The receipt is stored locally in SQLite and can be completed later with complete_receipt.
Inputs: action (required), input_hash (required), tags, model, +16 more.
generate_invoiceA
Generate a client invoice from cryptographically signed receipts within a date range. Aggregates receipt data by agent, action, or day and calculates total costs, token usage, and receipt counts. Supports JSON, CSV, and Markdown output formats. Each line item references a signed receipt for verifiable billing. Use to bill clients for AI agent work with cryptographic proof of every billed action.
Inputs: to (required), from (required), notes, format, +10 more.
get_chainA
Retrieve all receipts belonging to a chain, ordered by timestamp ascending to show the sequence of operations. A chain groups related receipts from a multi-step agent workflow. Returns the complete receipt objects for every step. Use to audit a complete workflow, calculate total chain cost and duration, or identify which step in a pipeline failed.
Inputs: chain_id (required).
get_judgmentsA
Retrieve all judgment receipts associated with a given receipt ID. Judgment receipts are linked via parent_receipt_id. Returns an array of judgment receipt objects ordered by timestamp, including verdict, score, criteria results, and confidence. Use to review the evaluation history of a receipt, compare multiple judgments, or audit AI quality assessments. Returns empty array if no judgments exist.
Inputs: receipt_id (required).
get_public_keyA
Export the Ed25519 public key used to sign all receipts on this instance. Returns the key as a 64-character hex string. Share this key with clients or third parties so they can independently verify receipt signatures without accessing your private key. The private key never leaves your machine — only the public key is needed for verification.
Inputs: no named parameters.
get_receiptA
Retrieve a single receipt by its ID from local SQLite storage. Returns the full receipt object including all 27 fields: identity, timestamps, action data, performance metrics, constraints, cryptographic proof, and metadata. Returns an error message if the receipt ID does not exist. Use to inspect a specific receipt or retrieve it before verification.
Inputs: receipt_id (required).
get_startedA
Display a getting-started guide with usage examples for all Agent Receipts tools. Shows how to record agent actions, verify receipts, use receipt chains, evaluate with constraints, and generate invoices. Call this tool first when setting up Agent Receipts or when you need a reference for available tools and their typical usage patterns.
Inputs: no named parameters.
judge_receiptA
Start an AI judgment evaluation for a receipt by creating a pending judgment receipt and returning a structured evaluation prompt. The host model (you) evaluates the receipt's output against the provided rubric criteria and then calls complete_judgment with the results. Use to assess output quality beyond simple pass/fail constraints — supports weighted criteria, partial verdicts, and confidence scores. Judgment receipts are themselves Ed25519-signed for auditability.
Inputs: rubric (required), receipt_id (required), output_summary_for_review.
list_receiptsA
Query and paginate receipts from local SQLite storage with optional filtering by agent, action, status, environment, type, chain, or tag. Supports sorting by timestamp, cost, or latency. Returns paginated results with total count, page info, and has_next/has_prev flags. Default: 50 receipts per page, sorted by timestamp descending. Use to audit agent activity, generate reports, or find specific receipts.
Inputs: tag, page, sort, limit, +6 more.
memory_auditA
Generate an audit report of memory operations. Shows what was remembered, forgotten, merged, and by which agents over a time period.
Inputs: to, from, agent_id, entity_id.
memory_contextA
Get a complete context dump of all stored memories — top entities, recent observations, active relationships, and preferences. Call this at the start of a conversation to understand what is already known about the user, their projects, and their preferences. Every context pull is logged as a signed receipt.
Inputs: scope, audited, max_entities, max_observations.
memory_entitiesB
List known entities (people, projects, organizations, etc.) with optional filtering. Returns entities with their observation counts.
Inputs: limit, query, scope, entity_type, +1 more.
memory_export_bundleA
Export memories as a portable, verifiable bundle. Includes entities, observations, relationships, source receipts, and the public key needed to verify them. Share with other agents or import into another Agent Receipts instance.
Inputs: entity_ids, description, include_receipts, include_forgotten.
memory_forgetB
Forget a specific observation or an entire entity. This is a soft delete — the memory is marked as forgotten but retained for audit purposes. The forget operation itself is recorded as a signed receipt.
Inputs: reason, entity_id, observation_id.
memory_import_bundleA
Import a memory bundle from another Agent Receipts instance. Verifies checksums before importing. Skips memories that already exist locally. The import operation itself is recorded as a signed receipt.
Inputs: bundle (required), skip_existing.
memory_observeA
Store a memory observation about a person, project, preference, or any entity. Automatically creates the entity if it doesn't exist. Every observation is cryptographically signed and linked to a receipt.
Inputs: content (required), entity_name (required), entity_type (required), tags, +4 more.
memory_provenanceA
Get the full provenance chain for a memory observation. Shows when it was created, which conversation produced it, which agent made the observation, and every subsequent modification.
Inputs: observation_id (required).
memory_recallA
Search and retrieve stored memories. Use text search to find relevant observations across all entities, or filter by entity type, specific entity, or scope. Every recall is logged as a receipt.
Inputs: limit, query, scope, audited, +3 more.
memory_relateA
Create a relationship between two entities (e.g., "Amin" builds "ModQuote"). Relationships are bidirectional for querying but stored with a direction.
Inputs: to_entity_id (required), from_entity_id (required), relationship_type (required), context, +1 more.
track_actionA
Create a completed Ed25519-signed receipt for an AI agent action with automatic SHA-256 hashing of input and output data. Records model usage, costs, latency, and constraint evaluations. Returns the signed receipt with receipt_id for future reference. Use this as the primary tool for recording agent actions — prefer over create_receipt + complete_receipt for single-step actions.
Inputs: action (required), tags, input, model, +14 more.
verify_receiptA
Cryptographically verify an Ed25519 signature on a stored receipt to confirm it has not been tampered with since signing. Extracts the 12-field signable payload, canonicalizes it, and verifies against the stored public key. Returns verified: true if the signature is valid. Use to audit receipts before using them as evidence or before completing payments based on agent work.
Inputs: receipt_id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Each tool has a clearly distinct purpose, grouped into receipt lifecycle, memory management, judgment evaluation, and utility. No two tools overlap significantly; even similar tools like track_action and create_receipt are differentiated by use case.
All tool names follow a consistent verb_noun pattern using snake_case (e.g., create_receipt, list_receipts, memory_observe). This pattern makes the tool set predictable and easy for an agent to infer.
At 24 tools, the set is on the higher side but still appropriate given the server's multi-domain scope (receipts, memory, judgments, invoicing). Each tool has a clear role, though some consolidation might be possible.
The server covers the full lifecycle of receipts, memory operations, and judgments with CRUD-like tools. Minor gaps exist (e.g., no direct update for memory observations, but provenance and re-observation can work around it). Overall, the surface is well-scoped for the stated purpose.
Maintenance
Related MCP Connectors
Verifiable execution records for AI agents: signed receipts, tamper-evident archives and portable evidence bundles, exposed via MCP and REST, with paid verify and anchor calls settled over x402.
Signed, append-only receipts of an AI agent's decisions and outcomes, with public proof links.
Issue signed receipts for AI agent actions; verify any receipt offline - free, no account.
Did it really happen? Independent signed receipts for AI agents: page, domain, email, heartbeat.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceTamper-evident audit logging for AI agents. Append-only, hash-chained, optionally Ed25519-signed log. The MCP server lets an agent keep and verify a record of what it actually did.8MIT
- AlicenseAqualityDmaintenanceMCP server that auto-emits tamper-evident receipts for every tool call, enabling EU AI Act Article 12 compliance with signed, chain-linked receipts.1Apache 2.0
- FlicenseNot gradedqualityDmaintenanceCryptographically anchored, tamper-evident evidence receipts for AI agents — verified run receipts, existence-at-time proofs, and cited answers from an anchored public record. Remote MCP with proof-gated settlement; attests existence and integrity, never truth.-
- AlicenseNot gradedqualityBmaintenanceTamper-evident audit trail for AI agent tool calls. Cryptographically signed, hash-chained records that prove what your agents did.3MIT