Research

Give your AI agents the power to pay and get paid.

Equip your AI agents with non-custodial wallets to earn and transact autonomously. With a dead-simple API and native support for stablecoins, mobile money, and cards, Ledger puts global payment rails directly into your agent's code—hosted on your own infrastructure.

Ledger is a research-first initiative exploring the future of autonomous finance. We aren't building a product; we're defining the architecture for an agent-led economy. Join us in mapping the infrastructure where the operator is no longer human.

science Early sketch — subject to change
Request
# Sketch: agent initiates a payment intent
curl -X POST https://ledger.yourdomain.com/api/intents \
  -H "X-API-Key: ledger_research_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "200.00",
    "currency": "USD",
    "recipient": "supplier_kj2a9...",
    "rails": ["auto"],
    "memo": "Invoice #4471"
  }'
Response 202 Accepted
{
  "intent_id": "int_9c7b3d8e1a5f",
  "status": "pending_approval",
  "resolved_rail": "mpesa",
  "resolved_amount_local": "25800.00",
  "resolved_currency_local": "KES",
  "fees": {
    "network": "0.10",
    "platform": "0.00"
  },
  "requires_approval": true
}
Principles

The constraints we're designing against.

Regardless of what the final shape looks like, Ledger will be built to these.

🔐

Non-custodial by default

Ledger never holds customer funds. Keys live with the operator — in their own wallet, mobile money account, or bank. Ledger orchestrates access; it doesn't take custody.

🛤️

Multi-rail, not multi-chain

Crypto matters, but so do M-Pesa, bank transfers, and cards. An agent paying a Kenyan supplier shouldn't need USDT; one paying a US vendor shouldn't need mobile money. Ledger abstracts the rail.

⚖️

Agent-initiated, policy-governed

Agents initiate; humans (or policy) approve. Every transaction passes through the same policy engine, the same audit log, regardless of rail.

🏠

Self-hosted

Same delivery model as Beacon and Vault. You deploy it. You hold the keys. We ship code, not custody.

🤖

MCP-first

The agent interface is the primary interface. The MCP surface defines the product — because the product is for agents.

Open questions

What we're still figuring out.

Published in the spirit of thinking in public. If any of these are problems you've solved or are working on, we'd like to hear from you.

Question 01

Custody boundary

Non-custodial is a principle, but the line is fuzzy. Does Ledger hold encrypted keys and sign on the operator's behalf? Does it only orchestrate the operator's existing wallets? Does the right answer differ by rail?

Question 02

Rail coverage at v1

Three rails shipped well beats ten rails shipped poorly. Currently weighing USDT on Tron, M-Pesa, and Stripe as an opinionated v1 — covering roughly 80% of real-world agent payment flows with reasonable geographic spread.

Question 03

Regulatory posture

Stablecoin regulation shifted substantially in 2025-2026. A non-custodial primitive is much further from regulated territory than a custodial one, but "further from" isn't "clear of." Researching the posture that keeps Ledger shippable across jurisdictions.

Question 04

Agent identity in transactions

Does the agent transact as the human, or as itself? If as itself, what's the legal shape of an agent that signs a transaction? This is a live question across the industry.

Question 05

Failure and reversal

Agents will send payments to the wrong address, at the wrong time, for the wrong amount. Stripe has refunds. Crypto doesn't. Mobile money sits somewhere in between. What's the reversal model for a multi-rail agent payment primitive?

Got answers?

Help us think through these.

If you've shipped something adjacent — custody, rail abstraction, agent payments — we'd like to hear from you.

Get in touch →
Early shape

Where our thinking is today.

Tentative. Subject to change as the research progresses.

Accounts
An operator registers one or more source accounts — a crypto wallet, an M-Pesa number, a Stripe account, a bank. Ledger learns how to transact on each.
Capabilities
Same pattern as Vault: an agent requests a capability ("pay up to $500 to this recipient, expires in 1 hour") and Ledger evaluates against policy.
Intents
The agent expresses what it wants to do ("pay supplier X $200") and Ledger resolves the rail, fees, and path. The agent doesn't need to know whether the payment goes through M-Pesa or USDT.
Settlement
On completion, Ledger writes the transaction to the audit log and fires a webhook. Failed or reversed transactions flow through the same log.
MCP surface
Tools for the agent to discover accounts, request capabilities, initiate intents, check balances, and inspect transaction history. Tools for humans to approve, revoke, and configure.

None of this is committed. It's where our thinking is today.

Stay Updated

Follow the research.

Ledger is early. We're publishing direction, principles, and open questions as we work through them. If any of this resonates — or if you're working on adjacent problems — we'd like to hear from you.

Low-volume. We send updates when the thinking moves, not on a schedule.