Role description
SapiomAbout Sapiom
Sapiom is building payment infrastructure for AI agents. We enable agents to make purchases for people, manage payments between businesses, and buy the compute, inference, and APIs they need to operate. As agents become part of everyday life, we're building toward the experiences people will use to trust them with their money: one place to set what agents can do, see what they did, and stay in control across every agent they use.
Through one integration, Sapiom connects agents to funding sources and payment methods. Our intent verification checks that each transaction matches what the person or business authorized. Spending controls define where and how much agents can spend, with a record of every transaction and its outcome. We're building toward a world where people and businesses can delegate payments to agents with confidence.
We're a small team in San Francisco with deep experience in payments and infrastructure. Our founder was Director of Engineering in Payments at Shopify for five years. We've raised $50 million in our first 12 months from Accel, Dragonfly, Coinbase Ventures, Okta Ventures, Menlo Ventures and Anthropic.
About the role
Agents are starting to buy things on their own, but the payment rails underneath them still assume a person at the keyboard. Our job is to let an agent complete a purchase inside the limits its owner set, and to keep proof of exactly what was agreed. In payments, a charge either moves money correctly or it doesn't, and a record either holds up when someone disputes it months later or it's worthless.
Our first version is live. You'll help turn it into payment infrastructure customers can depend on for every purchase their agents make, working directly with our CEO. This is a high-autonomy, Staff-level role. The right person has built card and checkout systems in production, knows where they break, and wants to set the architecture while the big decisions are still open. You'd rather design payments for agents from first principles than retrofit rails built for people.
What you will do
Own the payment systems that let agents spend safely: issuing and tokenizing the credentials agents pay with, completing checkout across a long tail of merchants, enforcing an owner's limits before money moves, and recovering cleanly when a payment fails or goes quiet. You'll take each from a problem statement to production, build the API and agent tools on top, and set the patterns other engineers build on. And that's only the beginning. Next come payments between businesses, and agents buying the compute, inference and APIs they run on.
By the end of your first year, the systems you own run in production at customer volume, every charge reconciles and can be explained from the record months later, and nobody has been charged twice.
Responsibilities
Build card issuing and tokenization for agents. Issue and manage virtual cards and network tokens scoped to a single agent, merchant or purchase, and integrate the card networks' agent programs as they mature.
Make checkout reliable across merchants. Complete purchases across a long tail of merchants where every flow differs, totals change and some steps still expect a human, using direct integrations, agentic commerce protocols and browser automation where needed.
Enforce limits before money moves. Turn an owner's spending rules into authorization-time controls, so an agent can't spend outside what was approved, rather than explaining it afterwards.
Design for failure. Build idempotent payment flows, retries and reconciliation against processor and network records, so a payment that times out or goes quiet is resolved correctly and never charged twice.
Keep proof of every transaction. Maintain a versioned record of what the buyer saw and agreed to that still holds up in a dispute or chargeback months later.
Design the API and agent tools. Build the public API, SDKs and the tools an agent calls, with contracts a model uses correctly, and build the interface on top of your own systems rather than handing it off.
Keep card data in scope and under control. Partner with counsel and compliance on PCI DSS, card-network rules and money movement, and design systems that keep card data out of places it doesn't need to be.
Requirements
8+ years building production software, at least four of them on payment systems that moved real money at scale, such as at a PSP, card issuer or processor, or on the payments team of a commerce platform.
Hands-on card payments experience. You've built on card issuing or processing, and you understand authorization, clearing, settlement, refunds and chargebacks well enough to debug them at the network level.
Tokenization and PCI. You've worked with network tokens or a card vault, designed systems inside PCI DSS scope, and made deliberate choices to keep that scope small.
Checkout integrations at depth. You've integrated payments into checkout flows across many merchants or PSPs, including 3DS, partial failures and totals that change mid-flow.
You design for failure. You've built idempotent APIs, retries and reconciliation against a number someone else is also computing, and you've owned a ledger or money-movement system through real incidents.
Staff-level ownership. You've set architecture from first principles on a multi-month project, starting from a problem statement rather than a spec, defended it, and other engineers built on what you shipped.
Full-stack range and fluent in AI. Strong TypeScript, you build the API and interface on top of your own systems, and you use AI tools daily with proof they made your work faster without lowering the bar.
Nice to have: You've worked with agentic payment protocols or the card networks' agent programs (such as Visa Intelligent Commerce, Mastercard Agent Pay, ACP or AP2), browser automation or request interception, or disputes and fraud systems. Bonus points if you've shipped something an LLM calls as a tool, or set the architecture at an early-stage company rather than inheriting it.
Logistics
Location: San Francisco in office five days a week.
Reports to: CEO