SPR (Sealed Payment Record)

SPR: the Sealed Payment Record

Your AI agent pays for data, compute and services, and your finance team and auditor can't see what each payment was for. SPR records every payment your agent makes, before and after it pays, sealed with your company's own key on your own machine. Anyone can check the seals. No service has to be trusted, Luca's included.

npx -y @luca-network/spr-mcp

Free and open: Apache-2.0, with a royalty-free patent commitment (PATENTS.md).

Use it from your AI tool

Every setup below runs the same MCP server on your machine. Set SPR_AGENT_ID (your agent) and SPR_ENTITY (the company it pays for); records go to SPR_DIR.

Claude Desktop: add to claude_desktop_config.json:

{ "mcpServers": { "spr": { "command": "npx", "args": ["-y", "@luca-network/spr-mcp"],

"env": { "SPR_AGENT_ID": "agt_research", "SPR_ENTITY": "Example Co", "SPR_DIR": "/Users/you/spr-books" } } } }

Cursor: the same block in .cursor/mcp.json.

Claude Code:

claude mcp add spr -e SPR_AGENT_ID=agt_research -e SPR_ENTITY="Example Co" -- npx -y @luca-network/spr-mcp

OpenAI Agents SDK and LangChain (JavaScript):

import { SprBook, toOpenAIAgentsTools, toLangChainTools } from "@luca-network/spr-sdk";

const book = new SprBook({ dir: "./books", agentId: "agt_research", entity: "Example Co" }); const tools = toOpenAIAgentsTools(book, tool); // tool from "@openai/agents"; or toLangChainTools(book, tool)

CrewAI, Microsoft Agent Framework, Google ADK and the Claude Agent SDK (Python): each connects to the MCP server in a few lines. See examples/.

Any other MCP client: run npx -y @luca-network/spr-mcp over stdio with the two settings above.

The agent then calls record_intent before it pays, check_payment to see whether the payment is inside what it declared, goes to the payee it named and wasn't paid already, and record_settlement after it pays. Each record is sealed in the book's folder.

A merchant's book works the same way for payments received: it can keep the buyer's own sealed intent, how the buyer authenticated, and the order and processor references, and export one payment's evidence for a chargeback response (export_dispute_pack).

A record shows:

• what the agent declared before it paid: the purpose, the most it could spend, and when the permission expired;
• what was actually paid, on which rail, to whom and when;
• whether the payment stayed inside what was declared;
• for x402 payments, whether the chain itself recorded which declaration the payment was made under. The payer signs a fingerprint of the sealed intent as the payment's nonce.

This repository holds:

Seal an x402 payment in one line

import { SprBook } from "@luca-network/spr-sdk";

import { withLuca } from "@luca-network/spr-sdk/x402";

const book = new SprBook({ dir: "./books", agentId: "agt_research", entity: "Example Co" }); const pay = withLuca(book, { signer: account });

const res = await pay("https://data.example/prices", { luca: { purpose: "Market data for the pricing model", max_amount_minor: 20000, currency: "USDC" }, }); res.luca.record; // sealed, matched to its intent, bound on chain

Check anything without Luca

npx spr-verify ./books-export --key company.pem    # a package, and whose it is

python -m spr ./books-export --key company.pem npx spr-verify --vectors # the library against the test vectors python -m spr --vectors # the Python SDK against the same vectors

company.pem is the company's public key, obtained from the company and never from the package (book.publicKey() gives it). Without --key the checkers show only that a package is consistent with the keys it carries, and say so.

Security problems: see SECURITY.md.

An implementation in any language conforms when it gives the same answers as packages/spr/vectors/vectors.json.

Local SPR and hosted Luca

The packages here run on your own machine and make no call to Luca. Luca's hosted service is a separate product that a book can be sent to.

A book moves across with one call once finance has registered its key: book.sendToLuca(). Luca checks every seal before it stores anything.

Send the book to Luca (optional)

Finance registers the book's key with Luca once (book.registerWithLuca), and then book.sendToLuca() sends the book. Luca checks every seal before it stores anything, and sending the same book again changes nothing. Write to hello@luca.network for an account.

Changes

What changed in each version, and what you may need to change on upgrading: CHANGELOG.md.

Status

This is draft 1 of the format and version 0.1 of the libraries. We expect to change things as people use them. Tell us what breaks or what's missing: open an issue, or write to hello@luca.network.

License

Apache License 2.0 for the code: see LICENSE. Luca's patent commitment, which lets anyone implement the format with or without this code, is in PATENTS.md.

Luca (luca.network) uses SPR for its hosted accounting of agent payments. That covers reading the rails, classifying to US GAAP and IFRS, posting to the ERP, labels agreed with counterparties, and the close.