
Before an AI agent moves money, treasury needs to govern its authority

By Andrew Blair
Head of Global Presales and Value AdvisoryShare
Autonomous payment execution is a delegation decision. The moment an AI agent can move money, treasury has delegated authority rather than simply automated a task, and the trust question shifts from “Was the recommendation right?” to “Was the action authorized, bounded, and appropriate?” That shift is the difference between walking and running.
Part 1 focused on trusting AI advice, and Part 2 focused on knowing the agent behind it. Running sets a harder standard, because treasury now has to govern an agent’s authority before it executes a payment.
A note from the International Monetary Fund frames the issue as a separation between three layers: intent, authorization, and settlement. An agent may help form the intent and coordinate the payment, but authorization and settlement require deterministic controls. That distinction is what supports the mandate floor, where the agent operates within defined boundaries while explicit rules decide whether the payment can proceed.
A payment mandate is not a prompt
Here’s a scenario most treasury teams will recognize. An agent identifies a recurring intercompany funding requirement, reviews the entity’s cash position, confirms the beneficiary, and prepares the transaction, only to find that the bank details have changed, the payment amount is higher, and another obligation falls due before the next funding cycle.
What should it do? If it proceeds, it could release the higher payment, leave the entity short for the next obligation, or bypass the verification step that the bank-detail change triggers. The model wouldn’t have failed in any obvious way. It would simply have followed an incomplete mandate into a real treasury problem.
Left without a mandate, most agents would proceed, and that’s exactly the problem. Treasury can’t delegate judgment without first defining the boundaries around it.
I call those boundaries the mandate floor: the minimum permissions, conditions, and stop rules that need to be in place before autonomous execution begins. A mandate should define the entities, accounts, payment types, beneficiaries, currencies, limits, data sources, and exceptions within scope, including which actions require human review.
Where a prompt tells an agent what someone wants, a mandate defines what the agent is allowed to do, and treasury needs the second.
The 3 a.m. test
I use a simple framework when discussing autonomous execution with finance leaders, which I call the 3 a.m. test. If an agent executes a payment at 3 a.m., can treasury answer four questions before the morning meeting?
Why did the payment happen? The record should tie it back to an approved invoice, funding requirement, debt obligation, or liquidity action.
Why was the agent allowed to execute it? Treasury should be able to point to the applicable mandate, limits, approval rules, and segregation-of-duties controls.
What happened when the agent encountered uncertainty? The workflow should show whether it completed, held, escalated, or stopped, because uncertainty can never become permission to proceed.
Who owns the decision? Can your treasury team name the human accountable if the agent was wrong at 3 a.m.? It has to be a person, not the system.
If treasury can’t answer those questions, it doesn’t yet have governed autonomy. What it has is an automated process that may be hard to explain after something goes wrong.
Exceptions are where governance gets tested
Routine payments aren’t the real test of an agent; exceptions are. An agent may work perfectly when bank files arrive on time, beneficiaries are unchanged, reconciliations are complete, and payment amounts match historical patterns, but treasury learns more when a feed is delayed, a beneficiary changes, an invoice is duplicated, or a payment breaches a threshold.
When data is stale, a beneficiary is new, a payment exceeds a threshold, or a bank or ERP system returns an error, the agent should pause or escalate rather than carry on. Often, the safest autonomous behavior is to stop.
Some CFOs will ask what we actually automated if every exception goes to a human. The answer is the routine, not the judgment. An agent can process the standard payment population at speed while routing the small number of ambiguous or high-risk cases to the people authorized to decide them.
Many automation designs assume the system should keep moving unless someone intervenes, and that’s an assumption treasury can’t accept. A payment workflow that fails open can turn a small data problem into a material financial event. Treasury isn’t a demo environment, and every exception needs an outcome that is both safe and auditable.
Who owns the decision?
Treasury has governed segregation of duties for decades, and the rules don’t change just because one of the actors is software.
An agent may prepare a payment and validate it against defined rules, and in a narrow set of use cases it may release the payment automatically. What it shouldn’t do is create the instruction, decide that the instruction is valid, and then treat its own conclusion as an independent approval.
The record needs to distinguish between the agent’s recommendation, transaction preparation, automated checks, human approval, final release, and reconciliation.
A human-in-the-loop control only matters when the human has a genuine decision to make, which is why a review after release isn’t an approval.
Nor should an agent be able to increase its own payment limit, add a beneficiary, change a policy, or bypass a control because a prompt asked it to. Those actions require authority from outside the agent’s mandate.
Run means visible and bounded
Autonomous execution shouldn’t become a set-and-forget capability, so treasury needs visibility while the agent is operating. Monitoring should flag unexpected volumes, repeated retries, unusual beneficiaries, payments outside normal windows, and attempts to exceed limits. Treasury also needs a practical way to intervene, whether that means pausing an agent, revoking permissions, suspending a workflow, or preventing release.
Reconciliation then closes the loop after execution. Was the payment accepted and settled for the expected amount, and did it create any unexpected liquidity, accounting, or exposure impact?
The payment record should connect the original intent, the agent’s actions, the bank response, and the final treasury outcome. When exceptions repeat, they may point to a data problem, an overly broad mandate, or a use case that simply doesn’t belong in autonomous execution.
Start with the operating model
The right path to autonomous payments isn’t to give an agent broad access and tighten controls once it has proven its value. If you tell yourself you’ll add governance later, you’re betting that nothing goes wrong while the organization is still learning, and that’s not a bet most treasurers should accept.
Start with narrow, repeatable use cases, and separate what the agent may recommend, prepare, initiate, and release. Define the required data, limits, escalation paths, and stop mechanisms, then test failure scenarios before expanding the mandate.
Running doesn’t mean running alone. It means operating within a treasury framework that makes authority explicit, exceptions safe, execution observable, and accountability impossible to lose.
Authority comes before autonomy.
Written By

Andrew Blair
Head of Global Presales and Value Advisory
Andrew Blair is the Head of Global Presales and Value Engineering at Kyriba, the leader in liquidity and risk management solutions. He teams globally across solution engineering, value consulting, and technical sales. Prior to joining Kyriba, Andrew spent nine years at GTreasury in professional services, account management, and presales leadership roles. He brings deep expertise in treasury technology, financial risk management, and helping organizations navigate complex enterprise sales cycles.
Related resources


