Routing Agent Payments Between Auto-Approve, Human Review, and Deny
If you let an agent spend money, sooner or later someone asks: "Who approved that?" The instinctive answer is to put a human in front of every transaction. It feels safe. In practice it is the design most likely to fail, because it turns approval into a chore. This post lays out one reasonable alternative: treat approval as a routing decision with three outcomes, made by policy before the transaction happens, with the reason recorded every time.
It is a design pattern, not the only valid one. Take the parts that fit your risk profile.
Why a single approval gate fails
A checkpoint on every call has two predictable failure modes.
It gets bypassed. When approvals pile up, the pressure is to widen what counts as pre-approved, add a "trust this agent" toggle, or route around the queue for anything urgent. The gate stays in the diagram but stops governing real behavior.
It gets rubber-stamped. An approver who sees dozens of near-identical requests an hour stops reading them. Approving becomes a reflex, and the one request that deserved scrutiny gets the same two-second click as the rest. The approval is still logged, so on paper you have oversight. In reality you have a record of clicks.
The common root is that the gate treats all spend as equally risky. Most agent spend is routine and bounded. A small share is unusual. A good design spends human attention only on that share.
The three outcomes
Instead of "approve or not", have policy evaluation return one of three outcomes for each proposed spend:
- Auto-approve. The request is inside the agent's per-transaction amount ceiling and its velocity ceiling (a maximum number of transactions per time window), and the merchant is one the agent is expected to use. No human is involved, and the decision is still logged.
- Route to a human. The request is not forbidden, but something makes it worth a second look: an amount above an approval threshold, or a merchant the agent has not used before. The request waits for a person to approve or deny it, and it expires if nobody answers.
- Deny. The request breaks a hard limit, such as a blocked merchant, a disallowed currency, an amount over the absolute cap, or an exhausted daily budget. No human is asked, because there is nothing to decide.
The important property is that the routing happens before the transaction, as a policy decision. It is not a reconciliation step after the bill arrives. Once money has moved, review can only explain what happened. A decision made up front can prevent it.
In Paitify these map to the AUTHORIZED, REQUIRES_APPROVAL, and DECLINED_BY_POLICY states of an authorization. Paitify is a policy and audit layer: your agent asks it for a decision before paying, and it does not move, hold, or custody funds.
What the approver actually needs to see
Routing to a human only helps if the human can make a real decision. A bare "Agent X wants to spend $480, approve?" invites a rubber stamp. The approver needs three things:
- The triggering policy. Why is this request here at all? "Amount above the $250 approval threshold" or "first time this agent has used this merchant" tells the approver what to look at. Without it they are guessing.
- The agent's recent spend. Is $480 normal for this agent, or does it follow a burst of smaller purchases? Context on recent activity separates a one-off from a pattern.
- The task context. What was the agent doing? A purchase that fits the task is very different from one that doesn't. Have the agent pass a short description of the purpose with each request, so the approver judges the spend against the goal.
Two further properties keep the process honest. The pending request should expire on its own rather than hang indefinitely, so a missed notification fails closed. And the approve or deny action should itself be recorded as an event.
Logging the reason, not just the amount
An audit trail that says "$480 to Vendor Y, approved" cannot answer the questions that matter later. Why was this approved without a human? Which rule sent it for review? Who decided, and when?
Record, for every decision, which rule produced it. Make entries append-only, so a decision can be explained but never quietly rewritten. When something looks wrong in review, you then replay the policy logic that applied at the time instead of reconstructing intent from memory. We cover this in more depth in Designing Auditable Guardrails.
A minimal config example
Here is an illustrative policy shape, in generic terms. The field names are simplified for readability, so check the API reference for the exact schema.
{
"name": "research-agent-default",
"maxTransactionAmount": { "amount": 500, "currency": "USD" },
"dailyLimit": { "amount": 2000, "currency": "USD" },
"velocity": { "maxTransactions": 10, "windowSeconds": 3600 },
"merchantAllowlist": ["Example Cloud Provider", "Example Data API"],
"approvalThreshold": {
"amountThreshold": { "amount": 250, "currency": "USD" },
"requireForNewMerchants": true,
"timeoutMinutes": 15
}
}
Read it as a routing table:
- Over $500 in one transaction, or past the daily budget, or past ten transactions in an hour: deny.
- Between $250 and $500, or a merchant the agent hasn't used before: route to a human, who has fifteen minutes to answer.
- Everything else, such as a $40 purchase from an allowlisted merchant: auto-approve, with the reason logged.
Start with ceilings tighter than you think you need, and loosen them as the audit log shows what the agent really does. It is far easier to widen a limit with evidence than to explain a loss after setting one blindly.
Putting it together
Approval for agent spend is most useful as a routing decision: cheap and automatic for the routine, human for the unusual, and a hard stop for what should never happen. Each outcome comes with a recorded reason, and the whole thing happens before the money moves.
Watch the demo video to see an agent get auto-approved and then routed for review, or get started free.