Allowed
Supplier Intelligence
Shortlists qualified suppliers from a live market index, filtered by the buyer budget.
$0.002 / request
AgentPay Index
Autonomous agent payments
Your AI can work.
Your AI can work.
Now let it pay.
Give AI agents a scoped budget to buy services. Every request is priced, checked against policy, signed, settled, and receipted.
Services your agent can buy
No subscriptions and no seat licences. The agent pays per request, and only for the requests the policy allows.
Allowed
Company Verification
Confirms registration status and beneficial ownership before the agent commits.
$0.001 / request
LedgerCheck
Allowed
ESG Intelligence
Returns an ESG profile and risk flags for a named supplier.
$0.005 / request
Terra Signal
Human checkout does not survive contact with a machine
Card rails were built around a person who reads a page, types a code and taps confirm. An agent buying an API call has none of that time.
Approval sits in the wrong place
A 3-D Secure prompt or an SMS code halts the workflow. The agent waits for a human who is asleep, and the task expires before anyone confirms.
The merchant cannot read the buyer
A provider has no way to tell a legitimate autonomous buyer from a runaway script, so it either refuses everything or accepts everything.
Every protocol invents its own money
Agents live inside fragmented tool and payment standards, so a working integration on one stack has to be rebuilt on the next.
Three layers, one exchange
The gateway is deliberately split so that negotiation, execution and verification can be reasoned about separately. A failure in one layer never silently becomes a payment.
Layer 1
Negotiation
The request carries no credentials. The provider answers with an HTTP 402 Payment Required and a machine-readable price. Nothing is charged and nothing is unlocked yet, so a mispriced call costs the agent nothing.
# provider response HTTP/1.1 402 Payment Required x-price: 0.002 x-currency: USDC x-pay-to: 9xQe…F4t x-network: solana-devnet x-valid-until: 1758169200
Layer 2
Signed execution
The payer signs an authorisation off-chain. A separate executor submits it and pays the network fee, so the agent never holds a key that can move arbitrary funds. Each authorisation carries a nonce and an expiry, which is what makes replay impossible.
// authorisation payload from: agent-payer to: provider.treasury value: 2000 // minor units validAfter: 1758168300 validBefore: 1758169200 nonce: 0x8f21…c3a9 transferWithAuthorization(…)
Layer 3
Verification and fulfilment
The provider re-checks the settlement against the requirement it originally published, then releases the resource. The receipt that comes back is the audit trail: what was asked, what policy decided, what settled, and on which network.
// merchant-side check amount_ok ✓ equals requirement recipient_ok ✓ matches treasury not_expired ✓ inside valid window nonce_unused ✓ replay protected → fulfil resource
Autonomous, but constrained
Freedom is granted as a budget with an expiry, not as a credential. Every rail below is enforced before a payment is signed, and every one of them is visible in the console.
Spend rails
Per-transaction cap, session budget and a rolling daily ceiling. A loop that tries to buy the same thing twice hits the ceiling, not the card.
Scoped capability
The agent holds a capability, not a card. Revoking it takes one call and does not touch the underlying funding account.
Know your agent
Each buyer presents a verifiable identity with its own history. Providers can price and meter a known agent differently from an anonymous one.
Validity windows
Authorisations expire. A signed intent that is not settled inside its window is worthless, so nothing lingers on the network waiting to be replayed.
Replay protection
Every authorisation carries a single-use nonce. Re-submitting a settled payment fails at the token contract, not in a support queue.
Human hand-off
Anything above the auto-approval threshold pauses and waits for an operator. The agent keeps its context instead of failing the task.
Settlement rails and protocol surface
One authorisation format, several ways to settle. The gateway stays protocol-agnostic so a standard change is a configuration change rather than a rewrite.
x402
HTTP-native payment headers for request-level monetisation.
ERC-3009
Signed transfer authorisations with nonces and validity windows.
EIP-712
Typed, human-readable structures for what the payer actually signs.
A2A
Agent-to-agent coordination, so a buyer can delegate a purchase.
MCP
Tool surfaces that expose paid capabilities to any compatible agent.
AP2
Mandate-based flows for agent-led purchasing with explicit consent.
Settlement rails in this buildDevnet
| Rail | Asset | Settlement time | Used for | Status |
|---|---|---|---|---|
| Solana | USDC | sub-second | Request-level micro-payments | Live in demo |
| EVM | USDC | ~1 block | Same authorisation format, different executor | Adapter |
| Card network | Fiat | T+1 | Where a provider only accepts cards | Adapter |
| Prepaid credits | Credits | instant | Batched settlement for multi-step tasks | Adapter |
Scope of this build
What this demo does not claim
- No real funds move. The ledger, prices and signatures are a sandboxed simulation on a devnet profile.
- No production key management, custody or multi-chain settlement infrastructure is wired up here.
- Proof of funds and dispute handling for high-value agent purchases remain roadmap, not shipped behaviour.
Questions operators ask first
An API key grants unlimited use of one service until someone revokes it. A scoped authorisation grants a named, capped, expiring permission to spend a specific amount with a specific provider. The agent can act inside the envelope and cannot act outside it, and the envelope closes on its own.
Three separate ceilings: a per-transaction cap, a session budget and a rolling daily limit. The gateway evaluates all of them before an authorisation is signed, so a runaway loop is refused at the source rather than after the fact. An operator can also halt the agent from the console, which stops authorisation immediately.
The payer signs and the executor submits. That separation means the executing service can cover the fee, so the agent never needs to hold a balance of the native token to transact. It is also what lets the authorisation stay a pure, verifiable signature.
Because the price is disclosed per request in the 402 response, a provider can quote per call, per token, per workflow step or by tier without changing anything about the integration. Metering becomes a property of the price the provider publishes, not of a contract signed months earlier.
The resource it paid for, plus a receipt tying the payment to the decision that made it necessary. That link is what makes the spend auditable months later, and it is why the ledger in this console is a context ledger rather than a list of amounts.
Agent run
Ready for a controlled run
One task, one budget, and a full trace of every request the gateway decided on. Start, pause or halt the agent at any point.
Operational trace
Simulated workflow
Marketplace
Services your agent can buy
Five purchasable capabilities, three currently inside the policy envelope. Change the allow-list in Policy and this catalogue follows.
Policy matrixEvaluated before every signature
| Capability | Category | Provider | Price | Policy |
|---|---|---|---|---|
| Supplier Intelligence | Sourcing | AgentPay Index | $0.002 | Allowed |
| Company Verification | Trust | LedgerCheck | $0.001 | Allowed |
| ESG Intelligence | Risk | Terra Signal | $0.005 | Allowed |
| Market Data Feed | Data | Meridian Feed | $0.003 | Outside policy |
| Contract Clause Review | Legal | Northwind Legal AI | $0.004 | Outside policy |
Payments
Contextual payment ledger
Every row carries the decision that produced it, so an operator can reconcile a charge against the agent's reasoning rather than guessing.
Settled
$0.000
Entries
0
| Time | Service | Amount | Status | Decision | Signature | Receipt |
|---|
No payments yet
Run the workflow and each authorisation, refusal and
escalation will land here with its receipt.
Controls
Active
Agent policy
These limits are evaluated before any authorisation is signed. Edits apply from the next request onwards.
Spend limitsHard ceilings
Allowed services3 of 5
Agent identityKYA
Agent idagent-payer…sol
Operatorprocurement.automation
Mandatescoped · revocable
Valid window15 min per run
Session spent$0.000