Skip to main content
Glama

Agent Receipts

Your agent says it's done. Prove it.

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

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

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

Live Demo Interactive Walkthrough npm version License: MIT

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


Automatic receipts

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

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

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

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

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

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

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

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

What these receipts do and don't prove:

  • They prove what Claude Code (or the MCP client) reported, signed outside the agent. The hook and the proxy run as separate processes, and each receipt is signed the moment the tool finishes, so the agent can't edit a receipt afterwards without breaking it. They don't prove the work was right, only what was done and that the record hasn't changed.

  • claude -p can stop the last one. In a scripted run, Claude Code stops background hooks still running when the run ends, so a tool call in the last moment of a run can go unrecorded.

  • The computer's owner controls the keys. Receipts are signed with keys in ~/.agent-receipts on your machine. They show the record wasn't changed after signing; someone who controls that machine could sign a false one. To show others, publish your public key so they know which key to trust.

  • stdio MCP servers only for now. Remote (HTTP) MCP servers aren't covered yet.

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-server

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

Get Started

Needs Node.js 22.16 or later.

1. Add the MCP Server

Claude Code:

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

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

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

2. Add the System Prompt

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

npx @agent-receipts/cli prompts claude-code

Copy the output into your project instructions or system prompt.

3. Start Using It

Your agent will now:

  • Call memory_context at the start of sessions to load what it knows about you

  • Call memory_observe when it learns something worth remembering

  • Call track_action when it performs significant actions

  • Sign everything with Ed25519

4. See What's Happening

npx @agent-receipts/dashboard    # Web UI at localhost: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.

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 trail

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

Portable memory bundles

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

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

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

The Problem

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

Three things are broken:

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

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

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

Why This Exists

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

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

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

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

How It's Different

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

  • Proof, not logs. Every receipt is signed with Ed25519 over every field (format v2). Logs can be edited and are written by the agent about itself; a receipt breaks if anything changes.

  • Anyone can verify it. Offline, in a browser, from the CLI or in code, with a public key. No account, no server, no trusting the person who sent it.

  • History you can't quietly rewrite. Receipts link to the one before them, and verify-chain detects edited, removed or forked receipts.

  • Memory with provenance. Every fact your agent remembers links to the receipt that created it, and can be exported as a bundle someone else can verify.

  • Local-first and free. npx and done. Keys and receipts stay in ~/.agent-receipts. MIT licensed.

What's Inside

  • Automatic receipts — Claude Code hooks (and a plugin) and an MCP proxy that sign every action as it happens

  • 24 MCP tools — memory, actions, verification, constraints, judgments, invoicing, bundles

  • 21 SDK methods — full TypeScript API

  • 17 CLI commands + 9 memory and 3 hooks subcommands — terminal-first

  • 20 dashboard pages — receipts, sessions, memory graph, chains, agents, constraints, judgments, invoices

  • 714 tests (697 across the packages, 17 for the website) — zero TypeScript any in package source

  • Ed25519 + SHA-256 — via @noble/ed25519 (pure JS, no native code); receipt format v2 signs every field

  • SQLite + FTS5 — Node's built-in SQLite, local-first with full-text memory search; no native modules to install

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, a worked quoting example

npm

All 7 packages

receipts.webaes.com

Magic Folder, install guide for Mac, Windows and Linux

verify.webaes.com

A real issuer's verify page

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

verify-chain <chain_id>

Verify every signature and link in a chain

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

Version

Description

@agent-receipts/schema

0.6.0

Zod schemas and TypeScript types

@agent-receipts/crypto

0.6.0

Ed25519 signing, verification, key management

@agent-receipts/mcp-server

0.6.0

MCP server with 24 tools

@agent-receipts/sdk

0.6.0

TypeScript SDK (21 methods)

@agent-receipts/cli

0.6.0

Command-line interface, Claude Code hooks, MCP proxy

@agent-receipts/dashboard

0.6.0

Mission Control web UI, on your own computer

@agent-receipts/magic-folder

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