Skip to main content
Glama

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.

Live Demo Interactive Walkthrough npm version License: MIT

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:

  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.

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 trail

The 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-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.

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

npx and done. Zero config.

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-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:3274
npx @agent-receipts/cli stats    # Terminal overview
npx @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.

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 warnings

  • Ed25519 + 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.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.

Interactive Demo

Try it in your browser — 60 seconds

Live Dashboard

See the full dashboard with sample data

How It Works

Receipt anatomy, memory model, ModQuote story

npm

All 6 packages

Action Tracking

  • 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

Memory

  • 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: true for 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

Bundles

  • ar.exportBundle(params?) — Export portable, verifiable memory bundle

  • ar.importBundle(bundle, params?) — Import and verify a memory bundle

Aliases

  • ar.emit(params) — Alias for track()

Tool

Description

Key Parameters

track_action

Track an agent action with automatic hashing

action, input, output, constraints

create_receipt

Create a receipt with pre-computed hashes

action, input_hash, output_hash

complete_receipt

Complete a pending receipt with results

receipt_id, output, status

verify_receipt

Verify the cryptographic signature

receipt_id

get_receipt

Retrieve a receipt by ID

receipt_id

list_receipts

List receipts with filtering

agent_id, status, chain_id

get_chain

Get all receipts in a chain

chain_id

get_public_key

Export the Ed25519 public key

—

judge_receipt

Start AI Judge evaluation

receipt_id, rubric

complete_judgment

Complete a pending judgment

receipt_id, verdict, score

get_judgments

Get all judgments for a receipt

receipt_id

cleanup

Delete expired receipts

dry_run, cleanup_memory

generate_invoice

Generate invoice from receipts

from, to, format

get_started

Getting-started guide

—

memory_context

Full context dump for session init

scope, max_entities

memory_observe

Store a memory observation

entity_name, entity_type, content

memory_recall

Search stored memories

query, entity_type, scope

memory_forget

Soft-delete observation or entity

entity_id or observation_id

memory_entities

List known entities

entity_type, scope, query

memory_relate

Create entity relationship

from_entity_id, to_entity_id, type

memory_provenance

Provenance chain for observation

observation_id

memory_audit

Memory operations audit report

agent_id, from, to

memory_export_bundle

Export portable memory bundle

entity_ids, include_receipts

memory_import_bundle

Import and verify memory bundle

bundle, skip_existing

Command

Description

init

Create data directory and generate signing keys

keys [--export] [--import]

Display, export, or import signing keys

inspect <id|file>

Pretty-print a receipt

verify <id|file> [--key]

Verify a receipt signature

list [--agent] [--status] [--json]

List receipts with filters

chain <chain_id> [--tree]

Show receipt chain

judgments <id> [--json]

List judgments for a receipt

cleanup [--dry-run]

Delete expired receipts

stats

Aggregate receipt statistics

export <id|--all> [--pretty]

Export receipts as JSON

invoice --from --to [--format]

Generate invoice

seed [--demo] [--count] [--clean]

Seed demo data

watch [--agent] [--action]

Watch for new receipts

prompts <client>

Setup guide (claude-code, cursor, system)

memory context

Memory context summary

memory observe <name> <type> <content>

Store observation

memory recall [query]

Search memories

memory entities [--type]

List entities

memory forget <id>

Forget observation or entity

memory audit

Memory audit report

memory provenance <obs_id>

Provenance chain

memory export

Export memories as JSON

memory import <file>

Import memories

Environment Variable

Description

Default

AGENT_RECEIPTS_DATA_DIR

Data directory path

~/.agent-receipts

AGENT_RECEIPTS_AGENT_ID

Default agent ID

local-agent

AGENT_RECEIPTS_ORG_ID

Organization ID

local-org

AGENT_RECEIPTS_ENVIRONMENT

Environment label

production

RECEIPT_SIGNING_PRIVATE_KEY

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 configuration

Packages

Package

Description

@agent-receipts/schema

Zod schemas and TypeScript types

@agent-receipts/crypto

Ed25519 signing, verification, key management

@agent-receipts/mcp-server

MCP server with 24 tools

@agent-receipts/sdk

TypeScript SDK (21 methods)

@agent-receipts/cli

Command-line interface

@agent-receipts/dashboard

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 tools
cleanupA

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

    A4/5.0

    Scored across 24 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count4/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Tamper-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.
      8
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      MCP server that auto-emits tamper-evident receipts for every tool call, enabling EU AI Act Article 12 compliance with signed, chain-linked receipts.
      1
      Apache 2.0
    • F
      license
      Not graded
      quality
      D
      maintenance
      Cryptographically 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.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Tamper-evident audit trail for AI agent tool calls. Cryptographically signed, hash-chained records that prove what your agents did.
      3
      MIT