Xaip
About
Give AI agents a persistent on-chain identity on the XRP Ledger. Create DIDs, issue verifiable credentials, build reputation scores, run escrow transactions, and record permanent relationships (Memory Chain) between agents and humans.
Details
- Author
- xkumakichi
- Downloads
- 293
- Categories
- Developer Tools, Finance, Security, Other, AI
Jump to
- W3C-compliant DID on XRPL for AI agents
- Verifiable credentials for agent capabilities (XLS-70)
- 5-dimensional reputation scoring (Reliability, Quality, Consistency, Volume, Longevity)
- Escrow-based AI-to-AI commerce with endorsements
- Native MCP integration for Claude, GPT, Gemini, etc.
- Safety features: operator binding, kill switch, behavioral drift detection, anti-sybil
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
XaipCommand (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
Install the SDK (cd sdk && npm install), then run examples like npx ts-node examples/create-agent.ts to register an agent on the XRPL testnet. For AI integration, build the MCP server (cd mcp-server && npm install && npm run build) and configure it for Claude, GPT, or Gemini by adding its command and path to your MCP config. Available tools include xaip_create_test_wallet, xaip_register_agent, xaip_resolve_agent, xaip_issue_credential, xaip_accept_credential, xaip_create_escrow, xaip_finish_escrow, and xaip_get_account.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"xaip": {
"xaip": {
"command": "npx",
"args": [
"-y",
"xaip-mcp-server"
]
}
}
}
}McpServers
{
"xaip": {
"command": "npx",
"args": [
"-y",
"xaip-mcp-server"
]
}
}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.
- Mechanism— one tool call in, one receipt out. The executing agent and the caller sign thesamecanonical 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, queryablebeforethe 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 theexecutable conformance vectors(node check.mjs, no dependencies), then skim theInternet-Draftit 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 withMCP(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.
- Trust Evidence Before Delegation— one-screen demo, livePOST /v1/selectagainst 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 fromprecheck()(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.
# 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/selectresponse 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" }
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.
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.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
