Agent Receipts
Agent Receipts
Your AI agent remembers everything — and you can prove it.
Persistent memory for AI agents, backed by cryptographic receipts. Every fact your agent learns is signed, traceable, and independently verifiable. No cloud required.
Try the Interactive Demo · Install in 30 Seconds · How It's Different
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.
Related MCP server: @humanaccepted/mcp
What Agent Receipts Does
Memory that actually works
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.
Proof that's actually proof
Every memory observation and every agent action produces a receipt — a signed JSON document with:
Ed25519 signature — 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
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.
Why This Exists
I was building ModQuote — a multi-tenant SaaS where AI agents generate quotes for automotive protection shops. Real money, real customers, real liability.
When Claude generated a $2,400 PPF quote, I needed answers: What vehicle data did it receive? What pricing rules did it apply? If a customer disputes the price, can I prove what happened — not with a log entry the agent wrote about itself, but with cryptographic proof?
I looked at the existing tools:
Mem0 — great memory, but no proof. It remembers things, but can't prove when or why it learned them. Memories are mutable.
Langfuse — great observability, but it's tracing, not proof. Logs are internal to your system, not verifiable by third parties.
Zep — temporal knowledge graph, but hosted and opaque.
None of them could answer: "Prove to someone outside your system that this specific agent took this specific action with this specific input at this specific time."
So I built Agent Receipts. Now every quote generation is a signed receipt. Every memory has a provenance chain. And when someone asks "how did the agent come up with that number?" — I hand them a receipt they can verify themselves.
How It's Different
Agent Receipts | Mem0 | Langfuse | Zep | |
Memory | Signed entity-observation graph | Smart extraction + consolidation | No memory | Temporal knowledge graph |
Proof | Ed25519 signed receipts | None | Mutable traces | None |
Verification | Offline, by anyone, no server | No | No | No |
Infrastructure |
| Requires LLM for extraction | Cloud or self-host | Cloud API |
Cost | Free forever (local) | Free tier, then paid | Free tier, then paid | Paid |
Export | Portable bundles with crypto verification | Export available | API export | No |
Audit trail | Immutable receipt chain | Mutable | Mutable logs | Mutable |
Agent Receipts isn't a better version of these tools. It's a different thing.
Mem0 answers: "What does my agent remember?" Langfuse answers: "What happened in my LLM pipeline?" Agent Receipts answers: "Can you prove it?"
Get Started
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.
What's Inside
24 MCP tools — memory, actions, verification, constraints, judgments, invoicing, bundles
21 SDK methods — full TypeScript API
14 CLI commands + 9 memory subcommands — terminal-first
18 dashboard pages — receipts, memory graph, chains, agents, constraints, judgments, invoices
492 tests — zero TypeScript
any, zero ESLint warningsEd25519 + SHA-256 — via
@noble/ed25519(audited, pure JS)SQLite + FTS5 — local-first with full-text memory search
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.
Links
Try it in your browser — 60 seconds | |
See the full dashboard with sample data | |
Receipt anatomy, memory model, ModQuote story | |
All 6 packages |
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 |
| 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 | Description |
Zod schemas and TypeScript types | |
Ed25519 signing, verification, key management | |
MCP server with 24 tools | |
TypeScript SDK (21 methods) | |
Command-line interface | |
Mission Control web UI |
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