Luca for developers

Give every payment your agent makes an accounting record

Your agent tells Luca what it is about to buy and why. When the payment settles, on whichever rail it uses, Luca matches it to that intent and to the mandate that allowed it, and returns a signed record that the company's finance team and auditors can check.

Luca has read-only access to the rails a company uses. It never holds, moves or blocks money, so adding it does not change how your agent pays.

Two calls

record_intent, just before paying: who the agent works for, the mandate it acts under, the purpose, the counterparty and the amount. Luca checks it against the mandate and budget, signs it, and answers with an intent ID and whether the payment fits. The purpose is sealed before the payment exists, so it can be dated and attributed later.

record_intent({
  "mandate": "MND-0042 · market data",
  "purpose": "Dataset query for the Q3 sector report",
  "counterparty": "Hollis Data",
  "amount": { "value": 40, "currency": "USD" }
})

← { "intent_id": "int_4be0…", "decision": "within_mandate" }

record_settlement, after paying, only where the rail does not report to Luca itself. For rails Luca reads directly, there is nothing more to do: Luca sees the payment settle and links it to the intent.

verify_record lets anyone holding a record check it against Luca's public key.

What comes back

• One signed record per payment. It joins what was allowed, what the agent said it was buying, and what settled. A change seals a new version that points to the old one; nothing is edited or deleted.
• Verifiable without Luca. Each record is signed with Ed25519. With the record and the public key, an auditor can check it independently.
• Accounting meaning. Each payment is classified under the company's own policy and tagged to US GAAP and IFRS concepts, and can be exported as an XBRL report.
• Into the books. Records post to the company's ERP as balanced journal entries, with a link from every entry back to the payments behind it.

How you connect

A REST API, with keys for each agent that can only declare that agent's own intents and report its own payments. An MCP server and an A2A agent will expose the same calls as tools, so an agent can use Luca without custom integration code.

Rails

Luca is neutral across rails. The same record works whether the payment settles on a corporate card (including agent card credentials), a stablecoin transfer over x402, a processor such as Stripe, or a card network's agent program. Where a rail issues its own authorization, such as an agent token or a signed mandate, Luca keeps a reference to it beside the company's mandate. Luca never sees or stores card numbers.

Security

• Read-only access to rails; no ability to move or stop money.
• A separate key for each agent, limited to that agent's own intents and payments.
• Original rail data kept exactly as received, with its hash inside the signed record.
• Signing keys held in a managed key service in production.

Get access

We are working with a small group of design partners: companies whose agents pay, and teams building those agents. Partners receive the full API reference and their keys with access.

Request access   or email hello@luca.network