The Stripe Agent Toolkit is a real unlock. An agent can now hold payment authority natively — create a charge, spin up a single-use virtual card, pay a vendor invoice — through function-calling tools, with no human clicking "confirm." If you've been waiting for agents to move money without a person babysitting each step, this is the release that does it.
Which is exactly why the interesting question isn't can the agent pay. It's whether you should let this particular one.
When you hand a new hire a corporate card, granting the card is the trivial part. The work is everything around it: you verified who they are, set a limit, scoped what they can spend on, and kept the ability to freeze it. Payment authority without those controls isn't a capability, it's a liability. An agent with the Stripe Agent Toolkit needs the same envelope — except it has to be programmatic, because there's no human in the loop to exercise judgment at swipe time.
What has to be true before an agent swipes
Four questions, and none of them are about payment rails:
- •Who is the operator behind this agent?:An agent is not a legal person. Someone deployed it. Is that someone a KYC-verified entity you can hold accountable, or an anonymous wallet?
- •Are they cleared?:Name and settling wallet against OFAC and sanctions lists — at the moment of the transaction, not at signup.
- •Are they allowed to buy this, here?:Jurisdiction, age, category restrictions. The Toolkit doesn't know your compliance rules; it just moves money.
- •Can you prove it later?:When finance or a regulator asks who authorized a charge, "an AI did it" is not an answer.
| Stripe Agent Toolkit | You — via AgentScore |
|---|---|
| Create charges, issue virtual cards | Decide if this agent may |
| Move money on the rails | Verify the operator behind it |
| Execute the payment | Clear sanctions, age, jurisdiction |
| — | Produce the audit trail |
The Toolkit moves the money. The gate decides whether it should.
The gate
This is one middleware call in front of the route that spends money. The Toolkit does the charge; AgentScore decides whether the charge is allowed to happen.
1import { agentscoreGate, getAgentScoreData } from '@agent-score/commerce/identity/hono';
2import { hasPaymentHeader } from '@agent-score/commerce/payment';
3
4const gate = agentscoreGate({
5 apiKey: process.env.AGENTSCORE_API_KEY!,
6 userAgent: `acme-procurement/${VERSION}`,
7 requireKyc: true, // operator must be a verified entity
8 requireSanctionsClear: true, // OFAC / UN / EU, name + wallet
9 minAge: 18,
10 allowedJurisdictions: ['US'],
11});
12
13// Only gate requests that actually carry payment — anonymous browsing stays open.
14app.use('/purchase', async (c, next) => {
15 if (!hasPaymentHeader(c.req.raw)) return next();
16 return gate(c, next);
17});
18
19app.post('/purchase', async (c) => {
20 const assess = getAgentScoreData(c); // full identity + policy result
21 // Non-compliant callers were already denied with a 403 + verify_url.
22 // If we're here, the operator is verified — hand off to the Stripe Agent Toolkit.
23 return chargeWithStripeToolkit(c);
24});The gate sits in front of /purchase. Non-compliant agents never reach the charge.
If you'd rather call it inline instead of as middleware, it's the same decision in one function:
1const result = await agentscore.assess(walletAddress, { policy });
2
3if (result.decision === 'deny') {
4 return c.json({
5 error: 'compliance_denied',
6 reasons: result.decision_reasons, // e.g. ["require_kyc failed"]
7 verify_url: result.verify_url, // where the operator goes to get verified
8 }, 403);
9}
10// result.decision === 'allow' → proceed to the Toolkit
One gate, two outcomes: verified operators reach the Toolkit; everyone else gets a 403 and a path to verify.
A real order
Prompt: "Reorder our monthly cloud credits and pay the vendor invoice."
The agent hits `/purchase` carrying its operator credential. The gate runs `assess`: the operator resolves to a KYC-verified business, sanctions clear, jurisdiction US. `decision: allow`. Only then does the Stripe Agent Toolkit issue the charge. Afterward the signer wallet is reported back with `associateWallet`, so the next transaction from that operator carries reputation instead of starting cold.
Now the same prompt from an agent whose operator never verified: `assess` returns `decision: deny`, `decision_reasons: ["require_kyc failed"]`, and a `verify_url`. The agent bootstraps a verification session, the human behind it completes KYC once, and the retry goes through. The card never swiped for an identity you couldn't name.
The point
The Stripe Agent Toolkit makes it trivial to let agents spend. That's precisely why you want a single place that decides whether a given agent should — before the money moves, not in a dispute afterward. Granting payment authority is easy now. Governing it is the actual product.
Giving agents payment authority?
See how the gate worksReady to power your agents with secure commerce?
Join innovators using AgentScore to accept payments, verify buyers, and ensure compliance for every AI-driven transaction.
Read More Blog Posts
Coinbase CDP CLI Brings Terminal-First Agent Signing and Wallet Delegation
Coinbase released CLI tooling and MCP server support to simplify how developers integrate onchain wallets into autonomous systems. 22 words. Engineers can now a
Coinbase CDP Unlocks Agent-Native Wallets and Delegated Signing for Autonomous Commerce
Autonomous agents need on-chain transacting capability without human approval loops. Coinbase CDP now ships the infrastructure to make that work. Engineers can