The problem

Your agent tries to pay and the payment does not go through. Unlike a confirmation that simply did not arrive, this is a genuine failure: the payment is being refused or erroring, and the agent cannot complete it. The task stalls, the agent may retry uselessly, and you are left to work out why a payment that should have succeeded did not. Something is actively blocking it, and until you know what, you cannot fix it.

This is the payment-not-going-through problem, and the key to solving it is that not going through is not one thing. Payments fail for distinct reasons, and each reason needs a different response. Treating all failures the same, retrying blindly, raising limits reflexively, or assuming the worst, either does not help or makes things worse. The symptom is a failing payment; the fix is to identify which kind of failure it is and respond to that kind specifically, which this page walks through.

The four kinds of failure

There are four common reasons an agent payment does not go through, and naming them is the first step. First, a spend-limit refusal: the payment exceeds the agent's per-transaction cap or its remaining period allowance, so the spend policy refuses it. Second, insufficient balance: the wallet does not hold enough USDC to cover the payment. Third, a transient settle error: the settle step returns a 503 during the chain-adapter rollout, meaning settlement is temporarily unavailable rather than permanently failed. Fourth, an upstream error: the service the agent is paying returned its own error, unrelated to the payment mechanism.

These four cover the large majority of not-going-through cases, and they are genuinely different problems. A limit refusal is the control working; insufficient balance is a funding issue; a transient 503 is a temporary infrastructure hiccup; an upstream error is the other service's problem. Because the causes differ, the fixes differ, which is why lumping them together as the payment failed leads to the wrong response. Identify the kind first.

Tell which kind it is

Distinguishing the kinds is usually quick from the signal you get. A spend-limit refusal comes with a rejection that indicates the limit or policy, and you can confirm by checking the payment amount against the agent's spend limit, if the amount exceeds the cap or remaining allowance, that is it. Insufficient balance shows as a balance-related failure, and you confirm by checking the wallet balance against the amount. A transient settle error appears as a 503 from the settle step, distinct from a refusal.

An upstream error is the service's own error response, which you can tell because it comes from the endpoint the agent is paying rather than from settlement, and it would occur regardless of payment. So the diagnosis is: check the error or rejection reason, then confirm against the obvious facts, the limit, the balance, the status code, the source of the error. A minute of this points clearly at one of the four, and from there the fix follows. The full taxonomy and how the platform surfaces these is in how-to-handle-failed-agent-payments.

The fix per kind

Each kind has its own fix. For a spend-limit refusal, decide whether the payment is legitimate: if it is and simply exceeds a too-tight limit, raise the limit in the dashboard; if it is larger than intended, the refusal is the control working, so leave the limit and fix whatever made the agent attempt an oversized payment. For insufficient balance, fund the wallet with USDC so it can cover the payment, the simplest fix once identified.

For a transient settle 503, do not treat it as final: confirm the payment did not already settle, then retry with bounded backoff, since this is the one kind where a careful retry is appropriate. For an upstream error, handle it like any failed API call, inspect the service's error, fix the request or back off, since the payment mechanism is fine. Applying the right fix to the right kind resolves the failure cleanly, whereas applying one fix to all kinds, say, retrying everything, fixes only the transient case and mishandles the rest.

Never retry blindly

The single most important rule is never to retry a failed payment blindly. Retrying is appropriate only for the transient 503, and even then only after confirming the payment did not already go through, to avoid double-paying. For the other three kinds, retrying does not help and can harm: retrying a limit refusal just refuses again, retrying an insufficient-balance failure fails again, and retrying an upstream error hammers a service that is already failing.

Blind retry is also dangerous because some failures are ambiguous about whether the payment settled, and an immediate retry could pay twice. So the discipline is: identify the kind, and retry only the transient case with bounded backoff after confirming non-settlement. This is why diagnosis matters so much, the correct response to not going through depends entirely on which kind it is, and a blanket retry policy is precisely the wrong approach. Treat retry as a specific tool for one failure kind, not a default reaction to all.

Not the same as not confirming

It is worth distinguishing this problem from a payment that settled but did not confirm, because they look similar and have opposite fixes. Not going through means the payment genuinely failed, refused, unfunded, transiently errored, or upstream-errored, and the fixes above apply. Not confirming means the payment likely settled but your system did not register it, usually a webhook or confirmation-path issue, and the fix is to repair confirmation, not to re-attempt the payment.

Confusing the two is costly: if you treat a settled-but-unconfirmed payment as a failure and retry it, you may pay twice; if you treat a genuine failure as a confirmation issue, you wait for an event that will never come. So before applying the fixes here, confirm the payment actually failed rather than merely failing to confirm, by checking its status with a lookup. If it settled, you have the not-confirming problem instead, covered in ai-agent-payment-not-confirming.

Reduce failures before they happen

Beyond fixing failures as they occur, you can reduce how often payments fail to go through. Keep the agent's wallet funded with enough headroom that it does not hit empty mid-task, perhaps with a low-balance alert or an auto-top-up routine, which removes the insufficient-balance kind. Size the spend limit to the agent's real needs so legitimate payments are not refused while excess still is, which removes most spurious limit refusals. And have the agent read its spend limit to plan, so it avoids attempting a payment it cannot afford rather than failing on it.

For the transient 503, a sensible bounded-retry policy in your payment path means the occasional temporary error is handled automatically rather than surfacing as a stuck task. Together these turn the common failure kinds from incidents into non-events: a funded, well-bounded, plan-aware agent with a retry policy for transients simply fails far less often. So part of solving not-going-through is preventing the avoidable kinds up front, leaving only the genuine cases to diagnose.

Related reading

If an agent payment is not going through, the full failure taxonomy and per-kind handling is in how-to-handle-failed-agent-payments, and the related but opposite case of a payment that settled but did not confirm is in ai-agent-payment-not-confirming. Together they cover both genuine failures and confirmation gaps. Pricing is on the pricing page.