Agent Receipts
About
Cryptographic accountability for AI agents. Ed25519-signed receipts for every MCP tool call — constraints, chains, AI judgment, invoicing, local dashboard.
Details
- Author
- webaesbyamin
- Downloads
- 270
- Categories
- Developer Tools, AI
Jump to
- Ed25519 signed receipts with local key generation
- 14 MCP tools for tracking, verifying, and judging
- Constraint evaluation (max latency, max cost, min confidence)
- Receipt chains for multi-step agent workflows
- AI judgment system with rubric-based quality scoring
- Invoice generation from receipt data
- Local SQLite storage and Next.js dashboard
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
Agent ReceiptsCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Agent Receipts works with any MCP-compatible client (Claude Desktop, Cursor, VS Code). It exposes 14 MCP tools including track_action, verify_receipt, judge_receipt, and generate_invoice. A live demo is available at https://agent-receipts-web.vercel.app.
create_receipt
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.
complete_receipt
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.
track_action
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.
verify_receipt
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.
get_receipt
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.
list_receipts
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.
get_chain
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.
get_public_key
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.
judge_receipt
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.
complete_judgment
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.
get_judgments
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.
cleanup
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.
generate_invoice
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.
get_started
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.
memory_observe
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.
memory_recall
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.
memory_forget
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.
memory_entities
List known entities (people, projects, organizations, etc.) with optional filtering. Returns entities with their observation counts.
memory_relate
Create a relationship between two entities (e.g., "Amin" builds "ModQuote"). Relationships are bidirectional for querying but stored with a direction.
memory_provenance
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.
memory_audit
Generate an audit report of memory operations. Shows what was remembered, forgotten, merged, and by which agents over a time period.
memory_context
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.
memory_export_bundle
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.
memory_import_bundle
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.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"agent receipts": {
"agent-receipts": {
"command": "npx",
"args": [
"@agent-receipts/mcp-server"
]
}
}
}
}McpServers
{
"agent-receipts": {
"command": "npx",
"args": [
"@agent-receipts/mcp-server"
]
}
}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
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.
-
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.
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 trail
The agent handles this automatically when you add thesystem prompt. You don't manage memory manually.
Every memory observation and every agent action produces areceipt— 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.
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.
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?
- 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.
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?"
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"] } } }
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.
- Callmemory_contextat the start of sessions to load what it knows about you
- Callmemory_observewhen it learns something worth remembering
- Calltrack_actionwhen it performs significant actions
- Sign everything with Ed25519
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 remembers
- 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 TypeScriptany, zero ESLint warnings
- Ed25519 + SHA-256— via@noble/ed25519(audited, pure JS)
- SQLite + FTS5— local-first with full-text memory search
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.
- ar.track(params)— Track a completed action with automatic hashing
- ar.start(params)— Create a pending receipt
- ar.complete(receiptId, params)— Complete a pending receipt
- ar.verify(receiptId)— Verify a receipt's Ed25519 signature
- ar.get(receiptId)— Get a receipt by ID
- ar.list(filter?)— List receipts with filtering and pagination
- ar.getPublicKey()— Get the signing public key
- ar.getJudgments(receiptId)— Get judgments for a receipt
- ar.cleanup()— Delete expired receipts
- ar.generateInvoice(options)— Generate invoice from receipts
- ar.context(params?)— Get full memory context dump for session init
- ar.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 entities
- ar.relate(params)— Create entity relationship
- ar.provenance(observationId)— Get provenance chain
- ar.memoryAudit(params?)— Memory audit report
- ar.exportBundle(params?)— Export portable, verifiable memory bundle
- ar.importBundle(bundle, params?)— Import and verify a memory bundle
~/.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
- 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
Built byAmin Suleiman— buildingModQuoteandAgent Receipts.
This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.
Create crafted UI components inspired by the best 21st.dev design engineers.
Bring agent evaluations, observability, and synthetic test set generation directly into your IDE for free with Galileo's new MCP server
An MCP server to help AI assistants to answer questions and generate AccelByte Extend SDK code more effectively .
MCP server for AI Diagram Maker — generate beautiful software engineering diagrams directly inside Cursor, Claude Desktop, Claude Code, or any MCP-compatible AI agent
ALAPI MCP Tools,Call hundreds of API interfaces via MCP
AI-powered SVG animation generator that transforms static files into animated SVG components using the Allyson platform
MCP server that gives AI assistants on-demand access to 1,500+ amCharts docs, ~300 code examples, and 1000+ class API references.
APIMatic MCP Server is used to validate OpenAPI specifications using APIMatic. The server processes OpenAPI files and returns validation summaries by leveraging APIMatic’s API.
One shared context layer for AI agents and humans — live API specs, DB schemas, and versioned contracts across repos so every agent and teammate works from the same source of truth.
Build and deploy full-stack Next.js apps with 98 tools for React, AWS, and MongoDB
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
