XAIP — Signed Execution Receipts for AI Agent Tool Calls

Evidence before delegation. Wrap an agent's tool calls once; use the receipt history locally today, and share the same signed receipts later as portable, independently verifiable evidence.

XAIP is a provider-neutral signed execution evidence layer for AI agent tool calls. It records co-signed receipts — both the executing agent and the caller sign the same canonical record, so neither side can unilaterally fabricate one — across MCP, LangChain.js, OpenAI-compatible tool-call loops, and other runtimes, then exposes historical execution evidence that agents, developers, or policy layers can inspect before delegation.

Receipts are the primary artifact. Trust scores are one derived view over those receipts — not a claim of absolute safety or correctness.

XAIP in 30 seconds

• Mechanism — one tool call in, one receipt out. The executing agent and the caller sign the same canonical record (Ed25519 over JCS), so neither side can unilaterally fabricate or repudiate it. Only hashes of input/output are carried; content never leaves your machine.
• What you get on day one — a verifiable history of what your own agent's tools actually did, queryable before the next delegation (precheck()). Useful single-player; no network of other users required.
• What XAIP is not — not a sandbox, not an approval engine, not a payment rail, not a safety guarantee. It makes execution evidence visible; you decide what to trust.

Pick your depth: 3 minutes — produce your first signed receipt · 10 minutes — verify the format yourself: run the executable conformance vectors (node check.mjs, no dependencies), then skim the Internet-Draft it pins.

Live demo: three candidate servers, side-by-side comparison without and with XAIP. Open in browser →

Provider-agnostic by design. XAIP is a trust layer for any tool-using agent. The reference implementation and live data start with MCP (Model Context Protocol) — because that's where the broadest fleet of public tool servers exists today — but the receipt format, signing, and scoring apply equally to LangChain tools, OpenAI function calling, A2A, and proprietary agent stacks. MCP is the first integration, not the only one.

Live dashboard: https://xkumakichi.github.io/xaip-protocol/ — current public trust scores, auto-refreshed, no auth. The current public dataset is MCP-heavy because MCP was the first integration target.

Entry points

• Trust Evidence Before Delegation — one-screen demo, live POST /v1/select against three contrasting candidates.
• Before Payment Evidence Demo — one-screen demo: what an agent sees about a paid closed-source skill before paying, with vs without execution evidence from precheck() (three fictional candidates, seeded fixture).
• Browser playground — read-only demo of trust-aware selection.
• 60-second overview — the problem XAIP is trying to address.
• Future direction — long-term hypothesis, open questions, and current research asks.
• Single-caller dominance case study — a real failure mode surfaced in XAIP's own public dataset on 2026-05-13, and what it implies for caller diversity.
• Agent Trust Check design — planned diagnostic concept.
• Class-aware scoring design — future design note; not live scoring behavior.
• Emit receipts from anything — how to produce XAIP receipts from any tool system.
• precheck() API guide — SDK helper for execution evidence before delegation.
• Run xaip-caller — contribute signed receipts without running MCP.

Try It Now

The API is live. No signup, no API key.

# Check trust score for a scored tool server
curl https://xaip-trust-api.kuma-github.workers.dev/v1/trust/context7

# Batch query
curl "https://xaip-trust-api.kuma-github.workers.dev/v1/trust?slugs=context7,sequential-thinking,filesystem"

# Decision engine: rank candidates by available execution evidence
curl -X POST https://xaip-trust-api.kuma-github.workers.dev/v1/select \
  -H "Content-Type: application/json" \
  -d '{"task":"Fetch React docs","candidates":["context7","sequential-thinking","unknown-server"]}'

The /v1/select response tells you which server to use, why, and what would happen without XAIP:

{
  "selected": "context7",
  "reason": "Highest trust among scored candidates based on current verified receipts",
  "rejected": [{ "slug": "unknown-server", "reason": "unscored — no execution evidence available" }],
  "withoutXAIP": "Random selection would pick an unscored server 33% of the time — no execution evidence available"
}

The Problem

Without trust scores, your agent is gambling:

┌────────────────┬────────────────┬───────────┬──────────────┐
│ Strategy       │ Server Hit     │ Success   │ Latency      │
├────────────────┼────────────────┼───────────┼──────────────┤
│ With XAIP      │ context7       │ ✓         │ ~3s          │
│ Random         │ unknown-mcp    │ ✗ error   │ ~8s (wasted) │
│ Try all (seq)  │ 3 servers      │ 1/3       │ ~11s total   │
└────────────────┴────────────────┴───────────┴──────────────┘

XAIP helps agents prefer candidates with stronger available execution evidence, skip unscored candidates when appropriate, and reduce avoidable failed calls.

How It Works

1. Select    POST /v1/select → ranks candidates by available execution evidence
2. Execute   Your agent calls the selected tool server
3. Report    POST /receipts → signed execution receipt feeds back into trust scores

Every execution receipt is Ed25519-signed and verified. Trust scores are computed using a Bayesian model with caller diversity weighting — not self-reported metrics.

Quick Start — your first signed receipt in under 5 minutes

The fastest path is the Claude Code hook: your normal MCP tool calls start producing signed receipts, with nothing but hashes leaving your machine. Measured end-to-end on a clean Windows 11 profile (Node 24, npm 11) — total command time was about 8 seconds; the steps are identical on macOS/Linux.

(Terminal replay rendered from the real captured outputs of that measurement — generator script.)

1. Install

npm install -g xaip-claude-hook

2. One command

xaip-claude-hook install

✓ XAIP Claude Code hook installed.
  C:\Users\you\.claude\settings.json

Next MCP tool call will emit a signed receipt to
  https://xaip-aggregator.kuma-github.workers.dev

3. One tool call

Open a new Claude Code session and let it call any MCP tool (for example, ask it to look up a library with context7). The hook signs and submits a receipt automatically — you do nothing.

4. One signed receipt

cat ~/.xaip/hook.log

2026-07-17T03:41:57.964Z POST context7/resolve-library-id ok=true lat=2402ms → 200 {"ok":true,"agentDid":"did:web:context7","callerVerified":true}

callerVerified: true is the aggregator confirming your Ed25519 caller signature over the canonical receipt payload. Only hashes and metadata (tool name, latency, success) were sent — never inputs, outputs, or file paths, and the log shows exactly what left the machine.

5. One verification result

curl https://xaip-trust-api.kuma-github.workers.dev/v1/trust/context7

{ "slug": "context7", "trust": 0.926, "receipts": 1044,
  "source": "xaip-aggregator-1 (single aggregator)" }

6. One precheck result — no invented trust

curl -X POST https://xaip-trust-api.kuma-github.workers.dev/v1/select \
  -H "Content-Type: application/json" \
  -d '{"task":"summarize a webpage","candidates":["context7","my-brand-new-server"]}'

{ "selected": "context7",
  "reason": "Only eligible candidate (trust 0.926, 1044 verified executions)",
  "rejected": [ { "slug": "my-brand-new-server",
                  "reason": "unscored — no execution evidence available" } ] }

This is the cold-start behavior, shown honestly: a server nobody has executed is unscored, not given a synthetic score. Evidence accumulates as receipts arrive; XAIP does not fabricate trust for tools without execution history.

If something doesn't work

• Hook never fires — the hook command must be resolvable when Claude Code spawns it: check that your npm global bin directory (npm config get prefix) is on PATH, then start a fresh session.
• PowerShell says "running scripts is disabled" — Windows' default execution policy blocks npm's .ps1 shims for interactive commands. Use xaip-claude-hook.cmd, run it from cmd, or Set-ExecutionPolicy -Scope CurrentUser RemoteSigned. Receipt emission is unaffected (the hook runs via the .cmd shim).
• Turn it off — export XAIP_DISABLED=1 disables temporarily; xaip-claude-hook uninstall removes the hook (keys/logs under ~/.xaip/ stay until you delete them). Receipts are pseudonymous: your caller DID is a per-install key, linked to nothing else.

Run the end-to-end demo