
Rigor over rigidity: how we built card acceptance for agents
It’s November.
You call a home services company. You’re worried about El Niño, and you want your home to be prepared. Someone picks up the phone, and you debate the specifics together. Should you trim the branches near your windows? What about the last time you cleared out the gutter? And you’re sure that there are no leaks in the roof, right?
A few minutes later, you settle on a quote and a date: next Saturday at 11am. To lock in the appointment, you give your card details and put down a deposit. Before you hang up, a receipt lands in your inbox.
Now imagine, for the entire call, you were talking to an agent. Not only did the agent answer your questions and facilitate your request, it also handled the payment for you.
An agent using Natural could already pay, send, request and transfer money. We launched Accept to add the missing piece: bringing payment collection into agent workflows.
With Accept, a business on Natural can take card payments, including one-time and recurring payments, in a variety of ways (with more ways coming soon!):
- through a hosted checkout link that an agent can create and send;
- through a checkout form embedded in the business’s own product; and
- over the phone
Payouts from these card payments can be configured to land in the same wallets that the business’s agents already use. Imagine the agent running the home service’s company above; the agent collects card payments for different jobs and, once the funds settle, orchestrates payments to vendors and contractors right away without having to wait on a separate payout from a merchant balance.
Accept was designed with these flows in mind, where agents can autonomously handle money movement in every direction. Accept is API-first. Everything from creating payment links to submitting evidence for a chargeback to using a voice agent to accept payment over the phone can be done by agents programmatically.
In this post, we’ll walk through what it took to bring card acquiring into Natural’s agent-native money movement platform, and the many engineering decisions that shaped what we built.
Money movement
We’ve spent this past year building out Natural’s money movement platform, including a ledger that tracks balances across every wallet, orchestration that coordinates each movement of money, and rail integrations with our banking provider Column N.A.
The money movement platform enables all existing transactions on Natural. It deserves its own deep dive, which we’ll be writing soon. But for now, we wanted to introduce two of its core models relevant to this post.
- Money movement request (MMR): a request to move funds. It can have one or more Route Legs.
- Route Leg: one movement of funds from a source to a destination, over a particular rail (such as an on-platform transfer, ACH, real-time payment, or wire).
To understand how these models are used in practice, suppose I initiate a $500 deposit into Wallet A. Under the hood, money movement creates a single MMR for this deposit, made up of two Route Legs:
- An ACH Debit from the external bank account into Wallet A’s Hold Account at Column N.A.; and
- A book transfer from the Hold Account to the Operating Account.
We wanted to build Accept on top of these same abstractions, using MMRs and Route Legs to orchestrate card payments. Before deciding what those movements should look like, we needed to first understand the lifecycle of an agent-led card payment and how our acquiring processor would settle the funds.
Finding the right shape for card payments
Card-acquiring processors typically settle funds to one bank account per merchant. Agentic payments require multiple wallets, each with its own audit trail and agent-specific controls. Building the abstractions to support that experience was a journey.
Fundamentally, there are three distinct stages of a card payment’s lifecycle:
- Authorization: The issuing bank approves a temporary hold for a specified amount.
- Capture: The merchant finalizes the charge for some or all of the authorized amount.
- Settlement: The captured funds are processed and ultimately transferred to the merchant’s settlement account.
Our initial design looked different from what we ended up shipping. Each merchant owned a dedicated Accept wallet, with TabaPay depositing all card proceeds into that wallet’s underlying FBO account. If a business wanted, or wanted its agent, to use those funds in another wallet, it would need to initiate a separate funds transfer.
This was the simplest design to build. Card proceeds would land directly in the dedicated Accept wallet, and the card Capture MMR would only need one Route Leg.
But we questioned whether this was the right product experience for businesses on Natural. Our programmable wallets are deliberately designed to let businesses separate funds for different purposes, each with its own agents and permissions.
Consider a home-services company. It has two crews, each with its own wallet:
- Tree crew: Collects payments for trimming jobs.
- Roofing crew: Collects payments for inspections and repairs.
Importantly, the roofing agent can’t touch the tree crew’s money, and vice versa.
Under our original design, all card payments would flow into a single Accept wallet. While this “single balance” setup is common in most payment providers’ dashboards, it would have worked against how businesses use Natural. Before card revenue could be put to use, a business would first have to transfer the funds out to the wallet that actually needed it. AI agents managing different business lines would have to share access to the same wallet to use those funds, meaning businesses couldn’t take advantage of wallet separation.
We ultimately figured out a way to support card payments at the wallet-level instead, preserving separation throughout the payment’s entire lifecycle, from the moment it’s created to when its proceeds become available for use. When creating a payment, an agent or business specifies the wallet that should receive its proceeds. Once the payment settles, the funds are paid into that wallet. Refunds for those payments are also funded from the same wallet.
Supporting this product experience requires Natural to execute and obscure significant routing complexity on the back end. TabaPay still settles all of a merchant’s card activity into a single settlement FBO, but we are responsible for distributing the proceeds to individual wallets, preserving a clean audit trail, and reflecting the multi-wallet experience in the product.
The final shape we arrived at was a card capture MMR with two route legs:
- The capture leg that collects the money over the card rail into the settlement FBO; and
- The second payout leg that books it into the FBO account of the card payment’s designated wallet.
Not just another rail
The dual route leg design gave us a way to deliver card proceeds to the right wallet. But supporting card acquiring wasn’t simply a matter of adding another rail to money movement. Card payments challenged previous assumptions we’d built our existing bank-centric transfer flows around.
| Bank transfer (ACH, wire) | Card payment | |
|---|---|---|
| When we need an answer | Later in a background workflow, from the bank or ACH network (async) | During checkout, from the customer’s bank (sync) |
| What limits it | The wallet’s balance | The authorization, plus what’s been captured and refunded |
| How cash arrives | One bank movement per transfer | One net amount per merchant, per settlement day |
Async to sync: getting an answer at checkout
Most money movements on Natural don’t need to immediately return a final outcome to the initial client request. ACH transfers are typically used for moving money between accounts or paying invoices. Even with faster rails like RTP or wire, there usually isn’t a customer waiting for the transfer to complete.
This shaped how we originally built our money movement API. When a client initiates an ACH, wire, or internal book transfer, we persist an MMR, perform a preliminary balance check for outbound movements, and start a durable Temporal workflow. We can then acknowledge that the transfer is being processed without waiting for its execution to complete.
The Temporal workflow handles the actual execution, retries, and failure recovery in the background. It takes the MMR, constructs a graph of Route Legs, and executes each leg. For external rail calls, we first durably record our intent to execute by marking the call as SUBMITTING. We then contact the provider outside of a database transaction and persist the outcome separately. Recording intent beforehand lets us recover from process crashes without losing track of calls that may already have gone out.
Card payments introduced a different requirement: needing an answer from the issuing bank in real time. A business needs to know whether a payment was approved before confirming an order, delivering a product, or providing a service. To get an answer, Natural sends an authorization request to TabaPay, our acquiring processor, which routes it through the card network to the issuing bank. The decision travels back along the same path. This entire round trip has to occur while the client is waiting for a response.

Figure 1. For immediate capture, the issuer’s decision returns while the API request is still open.
Fortunately, our existing architecture gave us a way to accommodate this without building a separate execution system.
For immediate-capture payments where authorization and capture happen in a single operation, we changed where execution begins. Instead of waiting for Temporal to construct and execute the Route Legs, we moved those initial steps into the API request itself.
We first persist the MMR and construct its entire Route Leg graph within a single database transaction. Then, while the API request is still open, we execute the first Route Leg, making the call to TabaPay and returning the issuer’s approval or decline directly to the client.
Once we have the result, we initiate the Temporal workflow as usual. Because our Route Leg creation and execution operations are already designed to be idempotent, the workflow can invoke those same operations, recognize the existing graph and previously recorded outcomes, and continue from where the synchronous request left off.
This allows us to meet the real-time requirements of immediate card authorization and capture while preserving the same durable orchestration and recovery mechanisms used by our other money movement flows.
Beyond wallet balances: enforcing limits
The money itself sits at our bank partner, Column N.A. Our ledger records how much of it belongs to each wallet, including money set aside (held in escrow) for payments that haven’t been completed yet.
A card authorization does not fit any of those. When a customer authorizes a $100 card payment, the customer’s bank sets aside $100 on their card. Nothing reaches Natural yet; no transfer of money has been initiated, so there’s nothing to book.
Yet that $100 is still a hard limit, and so is what can be refunded later:
- A $100 authorization can be captured for any amount up to $100.
- Total refunds and chargebacks combined can’t exceed the amount captured.
Rather than extending our ledger to represent these limits, we introduced a separate set of card-acquiring models for authorizations, captures, and refunds. An authorization record tracks the amount approved by the issuer, while capture and refund records track the individual operations against it and their outcomes. These records are associated with MMRs that coordinate their execution, but they live outside the ledger. They represent the state of an individual card payment, rather than money held or owed.
A successful capture is the first point at which a card payment enters our ledger as money TabaPay owes us. The ledger tracks the financial position of the transaction, but not how much of a particular authorization remains available for capture or how much of a capture can still be refunded. Those limits are derived from the card-acquiring records themselves.
We made two choices about how to enforce these limits:
- Remaining amounts are computed. The authorization model stores the approved amount. What’s left to capture is that amount minus any other live capture. What’s left to refund is the captured amount, minus live refunds and chargebacks. A stored counter can drift from the events that produced it, but a computed one can’t.
- Every check runs under a lock. Picture two $60 refunds arriving at the same moment against a $100 capture. Each checks capacity, sees $100, and passes. But now we’ve refunded $120. To prevent this, every capture or refund locks the authorization’s row before checking capacity. The second refund waits, sees $40 left, and is rejected.
One deposit, hundreds of payments
Along banking rails, every transfer corresponds to its own bank movement. Recall the $500 ACH deposit into Wallet A from earlier. That deposit had one MMR with two Route Legs, including an ACH debit that brought $500 into the wallet’s Hold account at Column. The external transfer produces an identifiable $500 bank credit that we can reconcile directly against its MMR.
Card acquiring works differently. We still create individual MMRs for every capture and refund, but TabaPay doesn’t move money separately for each transaction. Instead, it groups a merchant’s card activity into settlement cycles based on card network cutoffs, offsetting captures and refunds into a batched “net settlement” transfer.
Take the example below. During one settlement cycle, a merchant has two captures, $200 and $300, and a refund of $200. Natural tracks these as three separate payment operations. But rather than three corresponding bank movements, TabaPay nets them into a single $300 settlement, which arrives as a credit to the merchant’s settlement FBO.
There’s also a distinction between when funds are settled and when they actually move. TabaPay funds settlements on a subsequent banking day, meaning multiple settlement days can share the same funding date. As we’ll see later, the relationship between settlement cycles and bank movements isn’t always one-to-one.
This means we cannot reconcile card payments by matching each MMR directly to a bank movement. Instead, we connect individual payment operations to TabaPay’s reported batch settlements, then verify those aggregate settlement totals against the cash that actually moved.
In the next section, we’ll walk through how we built a reconciliation process that ensures that our records, TabaPay’s reports, and the actual cash movements all agree.
Reconciling settlement: three sources of truth
Let’s use the earlier example to illustrate the reconciliation flow.
On Wednesday morning, TabaPay sends us the settlement report for Tuesday’s cycle. The report details a merchant’s transaction-level activity, including captures, refunds, fees, and adjustments, along with the net amount TabaPay expects to fund. In our example, that means two captures of $200 and $300, a $200 refund, and a net settlement of $300. The reports represent TabaPay’s view of what happened but we still need to verify that they agree with our own records and with the money that actually moves.
We start with transaction reconciliation. For each capture and refund reported by TabaPay, we look for the corresponding operation in Natural, checking the amount and outcome. We also check the reverse: every operation we expect to have settled must appear in the settlement report. In our example, we’d expect to find both captures and the $200 refund, with matching amounts and outcomes.
This is followed by aggregate reconciliation. We verify that the individual transactions, fees, and adjustments add up to the report’s settlement total. For this cycle, the two captures and one refund should sum to $300.
Finally, there’s cash reconciliation. Wednesday is the funding date for Tuesday’s settlement. In this straightforward case, we expect to receive an ACH credit to the merchant’s settlement FBO from TabaPay sometime Wednesday afternoon. We compare the expected merchant funding amount against the bank movements that actually occurred and double check the cash amount matches what TabaPay reported.
Settlement is only validated when all three pass. Each settled capture’s MMR then completes its capture leg and begins its payout leg.
On paper, this seems simple: match the transactions, verify the totals, and find the bank movement. But once we started testing payments internally, the bank movements weren’t what we expected.
When settlements go negative
The first complication comes from refunds. When purchases outweigh refunds, TabaPay nets them and credits the rest to the merchant’s settlement account. When refunds push a day negative, TabaPay doesn’t debit the merchant. It pulls the difference from a separate program-level adjustments account instead. Money now moves in the opposite direction through a different account.
This means Natural must keep our adjustments FBO sufficiently funded to cover negative settlements, even though we won’t know which account TabaPay will debit until the day’s settlement is finalized.
When multiple settlement days share a funding date
Weekends further complicate reconciliation. Several settlement days can share one funding date, and amounts arrive split across different bank movements. Take a merchant with these net settlements:
| Settlement day | Net | Funded on |
|---|---|---|
| Friday | +$100 | Monday |
| Saturday | +$200 | Monday |
| Sunday | −$50 | Monday |
The three days net to +$250, but no $250 deposit ever arrives. Instead, TabaPay credits $300 to the merchant’s settlement FBO and separately debits $50 from our adjustments FBO. That creates three settlement days, one funding date, and two bank movements to reconcile.
To handle this, we reconcile cash movements by the funding date and bank account rather than by individual settlement day. We aggregate the expected credits and debits across settlement cycles, then verify those totals against the actual bank movements.
The complexity of multiple wallets
When we first decided to support wallet-level card payments, the product decision felt straightforward. Businesses already use multiple wallets on Natural. Accepting card payments shouldn’t work any differently.
What surprised us were the unexpected edge cases this decision introduced once we started tracing the actual flow of funds.
Even though each wallet stores its own balance, its card activity is netted with every other wallet’s before any money arrives. They all share one upstream funding pool. That makes it possible for one wallet’s activity to spill over into another’s, even though they’re technically separate accounts.
Refunds are the clearest example. To understand why, let’s return to the home-services company example.
On one settlement day, the tree crew collects $300 while the roofing crew refunds a $100 deposit. TabaPay nets those transactions and sends $200 to the merchant’s settlement FBO. But the tree crew is still owed the full $300. That refund is the roofing crew’s responsibility. We shouldn’t let one wallet’s refunds eat into another wallet’s payments. With agent-led payments, a clean audit trail of a wallet’s transactions is indispensable.
Our solution was to make each wallet fund its own refunds. When the roofing crew initiates its $100 refund, we first verify that its wallet can cover it. The refund MMR creates a book-transfer Route Leg that moves $100 from the roofing wallet into the merchant’s settlement FBO before we submit the refund to TabaPay.
By the time TabaPay’s $200 net settlement arrives, the roofing crew’s $100 is already there. Together, that’s the $300 owed to the tree crew.
| Step | Tree wallet | Roofing wallet | Merchant settlement FBO |
|---|---|---|---|
| Roofing funds its refund | — | −$100 | +$100 |
| TabaPay credits net settlement | — | — | +$200 |
| Tree payment pays out | +$300 | — | −$300 |
| Net change | +$300 | −$100 | $0 |
From the business’s perspective, the tree payment and roofing refund remain two independent money movements: the roofing wallet funds its refund, and the tree wallet receives its full proceeds. The fact that TabaPay nets them into a single settlement is completely invisible to the business.
Behind the scenes, maintaining that independence requires additional book transfers and accounting to preserve separate wallet balances on top of a shared settlement pool. But this is what allows card revenue to behave like every other dollar on Natural.
Rigor over rigidity
As a payments engineer, you learn to become wary of anything described as “close enough.” A missing cent is still a missing cent; you have to know where it went.
At the same time, it’s easy to mistake rigidity for rigor. When every cent needs to be accounted for, there’s a natural inclination to make every part of the system equally precise: another state, another account, another rule to cover an exception nobody anticipated. Even when each decision seems perfectly reasonable on its own, together they produce an increasingly complicated machine, with more interactions and edge cases than anyone bargained for.
Payment scenarios have a remarkable talent for finding those edge cases.
Building Accept reminded us that money doesn’t always move in the shape that software expects it to. We can track every capture and refund individually, but the card networks still net hundreds of transactions into a single settlement. We can give businesses independent wallets, but those wallets still share an upstream funding pool.
While we have to reconcile those differences, that doesn’t mean every part of our system needs to represent money at the same level of granularity, or that our original abstractions must remain sacred.
At Natural, correctness is something we will never compromise on. But correctness isn’t about making every part of a system equally rigid. It’s about understanding which guarantees matter, while being deliberate about the complexity we take on to protect them and optimize our product utility.
To start building with Accept, read the developer docs.
Natural is a financial technology company, not a bank. Wallet Account and banking services are provided by Column N.A., Member FDIC. Natural Accept is powered by other bank partners.