About 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.