On this page
- Key takeaways
- What JPMorgan and Hyundai Card actually proved this week
- Why payments break the usual agent safety model
- The five controls that actually matter
- A worked threshold example for an Australian SMB
- Reconciliation, liability and the evidence trail
- The Flowtivity play: four ways we build this
- Frequently asked questions
- Who should sign off on an AI agent payment?
- What does dual control mean for an AI agent?
- How do you stop an agent paying the same invoice twice?
- Does APRA CPS 230 apply to my small business?
- Who is liable if an agent pays the wrong supplier?
- Takeaways
Last Updated: 19 November 2026
Key takeaways
- ▪ Nobody should approve every agent payment, and nobody should approve none. The workable model is tiered: auto-pay below a small cap, one named approver in the middle band, two humans above a hard limit.
- ▪ JPMorgan's Kinexys unit and Hyundai Card completed a proof-of-concept on 18 November 2026 in which an AI agent requested a foreign exchange trade under a signed, machine-readable mandate, with no live money moved.
- ▪ Payments break the usual agent safety model because settlement is irreversible, the value at risk is the full amount, and a timeout retry can become a second payment.
- ▪ Five controls carry most of the risk: amount thresholds, dual control, per-agent spend and velocity caps, beneficiary allowlists, and idempotency keys enforced in the payment path rather than in the prompt.
- ▪ In our worked example, dual control above AUD 5,000 covers about 63% of spend while touching only 17% of invoices, so the heaviest control lands where the money is.
- ▪ Liability stays with the entity that granted the agent authority, and from 10 December 2026 APP 1.7 requires privacy policies to disclose automated decisions that significantly affect individuals.
Nobody should sign off on every transaction, and nobody should sign off on none. The workable answer is a tiered sign-off: small payments auto-execute inside a per-agent cap, mid-sized payments need one named approver, and anything above a hard threshold needs two humans who cannot approve the same payment by accident. That question became urgent this week when JPMorgan's Kinexys unit and Hyundai Card announced a proof-of-concept in which an AI agent managed euro liquidity and requested a foreign exchange trade under a signed, machine-readable mandate. Phase one moved no real money. Phase two, targeted for the first half of 2027, puts multiple agents in the same conversation. For an Australian SMB the build is roughly two to four weeks of engineering plus a documented control set, and the arithmetic below shows dual control on the top band covering about 63% of spend while touching only 17% of invoices.
What JPMorgan and Hyundai Card actually proved this week
The proof-of-concept showed an agent operating inside a signed mandate rather than loose instructions. Hyundai Card's agent monitored a blockchain deposit account, spotted a euro shortfall, requested foreign exchange quotes and asked Kinexys to execute. Kinexys's own agent checked the counterparty's identity and delegated authority, tested the request against the mandate, then chose to auto-execute, escalate to a human or deny. Every step landed in an immutable audit trail. That is a control architecture, not a chatbot with a bank login.
The primary source matters here because the headline coverage overstated it. The Tech Buzz reported that agents would "initiate, approve, and complete financial transactions independently" and framed the work as payments "without human oversight". JPMorgan's own newsroom post describes something narrower and more useful: a test environment with no live value movement, a human escalation path built into the counterparty agent's decision, and a mandate that bounds what the agent may do. The distinction is the whole point of this post. Autonomy inside a mandate is a design choice. Autonomy without one is an incident waiting for a date.
Wee Kee Toh, global head of Kinexys Insights, put the design philosophy plainly: "Agentic commerce will not scale on autonomy alone. It will require trusted autonomy." Every autonomous action, he said, needs a verified identity, a clear principal, a signed mandate and enforceable controls. CNBC reported that the second phase targets the first half of 2027 and will test agents negotiating and paying each other directly. Toh also told CNBC that the technology was "really not the biggest hurdle" and that governance and internal controls were harder to get right. That matches what we see in client work. The payment API is the easy part. The approval logic, the evidence trail and the exception handling are the project.
The scale numbers explain why banks care. Kinexys said in August 2026 that it had processed more than USD 4 trillion in transactions since inception, averaging about USD 7 billion a day. Hyundai Card completed a USD 20,000 USDT stablecoin transfer between Hyundai Motor's United States and Mexican subsidiaries in July 2026, with transfer and verification averaging seven minutes. Toh gave CNBC a concrete control example: an agent authorised to transact up to USD 5 million would be blocked above that threshold. The framework draws a box around the agent, and the agent cannot act outside it.
The risk data is less comforting. AvePoint's State of AI 2026 report, cited by CNBC, found that unauthorised autonomous agent actions were the third most common agent-related security breach, affecting 34.1% of companies that reported such incidents. Those actions included executing transactions and modifying data without approval. That is a vendor survey figure reported second-hand, so treat it as directional rather than definitive. AvePoint's chief executive, Tianyi Jiang, described the worst case as a cascading failure in which one compromised or hallucinating agent feeds bad data to another, triggering a chain of flawed transfers before a human notices. If you have already read how adversarial delegation steers an agent's choices, that failure mode will look familiar. The difference with payments is that the damage settles in seconds.
Why payments break the usual agent safety model
Most agent failures are recoverable. A wrong draft gets edited, a bad ticket gets reopened, a mislabelled record gets corrected. A payment is different in three ways: it is irreversible once settled, the value at risk is the full amount rather than the quality of the output, and settlement timing can beat your review cycle. A retry is not harmless either, because a retried payment instruction is a second payment unless the rail recognises it as the same request.
Irreversibility. Once a payment clears, reversal is a request to the recipient's bank, not a right. Recall works when the receiving institution cooperates and the funds are still there. It fails when the payee has moved the money, when the account is offshore, or when the payment went to a fraudster who never intended to give it back. An agent that can send money is an agent that can create a loss you cannot undo with a rollback script.
Value at risk. With most agent tasks you measure error rate. With payments you measure error rate multiplied by amount. A 2% failure rate on drafting is annoying. A 2% failure rate on a AUD 40,000 supplier run is AUD 800 of exposure per run, and the failures cluster on the unusual invoices, which are exactly the ones a threshold should have caught. This is why the control has to be amount-aware rather than confidence-aware. A model saying it is 97% sure is not a substitute for a human saying yes above AUD 5,000.
Settlement timing. Australian New Payments Platform transfers settle in near real time, around the clock. Batch payroll and BECS runs settle on a schedule. Foreign exchange has value dates and cut-off times. An agent working at machine speed can initiate, approve and settle a payment inside the window where a human reviewer is at lunch, asleep or on a plane. The control design has to assume the agent is faster than the escalation path, so the escalation has to happen before execution, not after.
Retries are not harmless. A timeout does not mean the payment failed. It means you did not hear back. If the agent retries on timeout without an idempotency key, the rail can treat the retry as a new instruction and pay twice. Stripe's idempotency documentation is explicit about this: a client-generated key lets the server recognise subsequent retries of the same request, and API v1 returns the saved response from the first request rather than performing the operation again. Keys can be pruned after 24 hours, so a retry the next day is a new payment. That detail matters more than most teams realise.

The five controls that actually matter
Five controls carry most of the risk: amount thresholds that route a payment to the right approver, dual control above a hard limit, per-agent spend caps and velocity limits, beneficiary allowlists that block first-time payees, and idempotency keys that make a retry safe. Around them sit reconciliation, an exception queue, an immutable audit log and a documented kill switch. None of these is exotic. All of them have to be enforced outside the model, in the payment path itself, because a prompt instruction is a suggestion and a policy check in the gateway is a wall.
1. Amount thresholds. Route by value, not by vendor or category alone. A payment under AUD 500 with a matched invoice and a known beneficiary can go straight through. A payment between AUD 500 and AUD 5,000 goes to one named approver with the invoice, the beneficiary history and the agent's reasoning attached. Above AUD 5,000, two approvers from different cost centres. The threshold should be a property of the payment instruction, evaluated by the gateway, not something the agent decides about itself.
2. Dual control encoded for machines. Four-eyes in a manual accounts payable team means two people independently review the same payment. For an agent, it means two distinct authenticated identities must approve the same payment ID, and the system must reject an approval where both identities resolve to the same person, the same device or the same service account. The agent can prepare the payment and attach evidence, but it cannot be one of the two approvers. If your identity provider cannot tell two humans apart reliably, fix that before you automate anything that moves money.
3. Per-agent spend caps and velocity limits. Give each agent its own budget, not the company's. A treasury agent might hold AUD 25,000 a day and AUD 120,000 a week. A payables agent might hold AUD 8,000 a day. Velocity limits catch the failure mode that amount limits miss: a hundred small payments that individually pass every threshold. Count payments per hour, per beneficiary and per agent, and trip a circuit breaker when the count or the cumulative value crosses the line. This is the same least-privilege thinking that applies to scoping an agent's access, applied to money instead of data.
4. Beneficiary allowlists. An agent should only pay parties that already exist in the vendor master with a verified bank account and a payment history. A new beneficiary is a change event, not a payment event. First payment to a new payee gets a hard cap, a 24 hour hold and a callback to a phone number on file, not a phone number in the invoice. This is the single control that stops most business email compromise variants, because the attacker's win condition is changing the account, not changing the amount.
5. Idempotency keys. Every payment instruction gets a deterministic key derived from the invoice ID, the beneficiary and the amount, generated before the first call and reused on every retry. The key must survive process restarts and be stored where the agent cannot rewrite it. If the rail supports idempotency, use it. If it does not, keep a local ledger of in-flight instructions and reconcile before retrying. Never let the agent invent a new key on retry, because that is how a timeout becomes a duplicate payment.

A worked threshold example for an Australian SMB
Take an SMB processing 300 supplier invoices a month at an average of AUD 2,580, so about AUD 774,200 a month or AUD 9.29 million a year. Put auto-pay at under AUD 500, single approval from AUD 500 to AUD 5,000, and dual control above AUD 5,000. That puts 40% of invoices on straight-through processing while dual control covers 63% of the spend. The control effort lands where the money is, which is the entire argument for tiering rather than reviewing everything.
Here is the band arithmetic, which is our arithmetic based on an assumed invoice distribution rather than a benchmark:
- Under AUD 500: 120 invoices averaging AUD 310, so AUD 37,200. That is 4.8% of spend and 40% of invoice volume.
- AUD 500 to AUD 5,000: 130 invoices averaging AUD 1,900, so AUD 247,000. That is 31.9% of spend and 43% of volume.
- Above AUD 5,000: 50 invoices averaging AUD 9,800, so AUD 490,000. That is 63.3% of spend and 17% of volume.
The three bands sum to AUD 774,200, which matches the monthly total, and the shares sum to 100%. The operational point is that the heaviest control, dual approval, applies to 50 payments a month rather than 300. A finance team can absorb 50 four-eyes reviews. It cannot absorb 300, which is why "review everything" quietly turns into "review nothing".
Now the effort. At six minutes of manual handling per invoice, 300 invoices is 1,800 minutes, or 30 hours a month. With the agent preparing every payment and humans reviewing only the 180 invoices in the two approval bands at two minutes each, review time falls to 360 minutes, or 6 hours. That is a saving of 24 hours a month, which is our arithmetic. At a loaded cost of AUD 65 an hour, that is AUD 1,560 a month, or AUD 18,720 a year. Whether that justifies the build depends on your error rate and your audit requirements, which is the same trade-off we set out in where AI automation ROI actually pays off.
The duplicate-payment exposure is the number that usually changes the conversation. If 8% of payment requests time out and the agent retries without an idempotency key, that is 24 invoices a month exposed to double payment. At the average invoice value of AUD 2,580, that is AUD 61,920 a month at risk, which is our arithmetic and assumes every retry duplicates. Even at a tenth of that hit rate, the control pays for itself faster than the labour saving does.
Reconciliation, liability and the evidence trail
Reconciliation is the control that catches what approval missed. Every agent-initiated payment should match to an approved request, a purchase order or an invoice, and anything unmatched should land in an exception queue with an owner and a clock. Liability sits with the entity that authorised the agent, not the model vendor, and the evidence that matters is the mandate, the approval record, the agent's reasoning trace and the settlement confirmation. CPS 230 pushes that expectation into contracts with service providers.
The exception queue deserves its own design. A payment that fails reconciliation should not be silently retried or quietly written off. It should create a case with the payment ID, the matched documents, the agent's reasoning, the approver identities and the settlement status, assigned to a named person with a service level target. The queue should also capture near misses: payments the gateway blocked because of a velocity limit or a new beneficiary. Near misses are the cheapest evidence you will ever get that the controls are working, and they are the first thing an auditor asks for.
On the regulatory side, CPS 230 requires APRA-regulated entities to manage operational risk with effective internal controls, keep critical operations inside tolerance levels through severe disruption, and manage service provider risk through a policy, formal agreements and robust monitoring. It also requires a material service provider register, and a provider can be a third party, a related party or a connected entity. An SMB is not directly regulated by APRA, but its bank, insurer or super fund is. If your agent sits inside a payment chain that a regulated entity depends on, expect CPS 230 language to appear in your contract: defined service levels, incident notification windows, audit rights and exit plans. That is the practical way the standard reaches a small business.
The privacy angle is separate and closer than most teams think. From 10 December 2026, APP 1.7 requires an APP entity to disclose in its privacy policy the kinds of personal information used by a computer program that makes, or does something substantially and directly related to making, a decision that could reasonably be expected to significantly affect an individual's rights or interests. APP 1.8 sets out what must be disclosed, including the kinds of decisions made solely by the program. A payment agent that decides whether to pay a sole trader, withhold a payment or flag a customer for collections can fall inside that description. The OAIC published the fact sheet, a government supplementary fact sheet and a flowchart on 30 September 2026, after 90 written submissions. This is an engineering and controls view, not legal advice. Your lawyer or privacy adviser signs off on the disclosure wording.
Liability is the question nobody wants to answer in a contract. In practice, the entity that granted the agent authority carries the loss, because the agent acted as its delegate. The model vendor will point to its terms. The payment provider will point to the mandate. The useful work is to make the delegation explicit: a written mandate that states the agent's principal, its purpose, its limits, its expiry and the human escalation path, plus a log that proves what the agent did and why. If you want the deeper version of that identity argument, it is in who your AI agent is when it logs into your bank account. The transaction-level controls here assume that identity problem is already solved.
The Flowtivity play: four ways we build this
We build the control layer, not the model. Four engagements cover most of what an Australian SMB needs: a payment control design sprint, a threshold and dual-control implementation against your accounting stack, an idempotency and reconciliation build, and a quarterly control attestation with evidence packs. Each is scoped to run on your infrastructure or ours, with local models where the data cannot leave. The point is to make the agent's authority explicit and testable before it touches a live account.
1. Payment control design sprint, two weeks, fixed fee. We map your current accounts payable flow, define the amount bands, name the approvers, write the mandate template and produce a one-page control matrix your board can sign. Deliverables include the threshold schedule, the dual-control rule, the beneficiary change procedure and the kill switch runbook. No code in this phase, which is deliberate. Most failures are design failures, and the design is cheaper to fix on paper.
2. Threshold and dual-control implementation, three to five weeks. We wire the policy checks into your payment path, whether that is your accounting platform, your bank's API or a payment orchestrator. Approvals run through your identity provider so the two approvers are provably two people. The agent gets its own service identity and its own budget, and every decision writes to an append-only log. We test with sandbox payments before a single live dollar moves.
3. Idempotency and reconciliation build, two to three weeks. We generate deterministic keys from invoice, beneficiary and amount, store them outside the agent's reach, and build the matching job that reconciles every agent payment to an approved request. Unmatched items go to an exception queue with an owner and a clock. We also instrument near misses so you can show an auditor that the controls fired, not just that nothing went wrong.
4. Quarterly control attestation, ongoing. Each quarter we re-test the thresholds, replay the retry scenarios, sample the approval records, review the exception queue and produce an evidence pack mapped to CPS 230 service provider expectations and APP 1.7 disclosure requirements. If you run agents across HR and finance, the scope questions are covered in whether AI agents should run HR and finance workflows, and the human review design in human in the loop for AI agents.

Frequently asked questions
The questions below are the ones Australian business owners and finance leads ask us most often when they are deciding whether an agent should be allowed to initiate payments. Short answers first, because the decision usually turns on one or two of them rather than on the whole architecture. Each answer is written to stand alone, so you can lift it into a board paper or a supplier questionnaire without needing the rest of the post for context.
Who should sign off on an AI agent payment?
A named human approver, not the agent, and never a shared login. Below a small cap the payment can auto-execute because the exposure is bounded. Above the cap, one approver who can see the invoice, the beneficiary history and the agent's reasoning. Above a hard limit, two approvers from different cost centres. The agent prepares and evidences the payment. It does not approve its own work.
What does dual control mean for an AI agent?
Two distinct authenticated humans must approve the same payment ID, and the system must reject approvals where both identities resolve to the same person, device or service account. The agent can be the preparer but never one of the two approvers. Encode the rule in the payment gateway, because a prompt that says "always get two approvals" is not a control.
How do you stop an agent paying the same invoice twice?
Use an idempotency key derived from the invoice ID, beneficiary and amount, generated once and reused on every retry. Store it outside the agent's control and reconcile in-flight instructions before retrying. Stripe's API returns the saved response for a repeated key rather than repeating the operation, and keys can expire after 24 hours, so a next-day retry needs its own reconciliation check.
Does APRA CPS 230 apply to my small business?
Not directly, because CPS 230 applies to APRA-regulated entities such as banks, insurers and super funds. It reaches you through contracts. If your agent sits in a payment chain a regulated entity relies on, expect service levels, incident notification windows, audit rights and exit plans in the agreement, because the regulated entity has to manage you as a service provider.
Who is liable if an agent pays the wrong supplier?
The entity that granted the agent authority generally carries the loss, because the agent acted as its delegate. The model vendor and the payment provider will both point to their terms. The practical protection is a written mandate with limits and an escalation path, plus an audit trail that proves what the agent did, what it checked and who approved. This is not legal advice, and your lawyer should review the mandate.
Takeaways
Agent payments are not a model problem, they are a control problem. The technology to initiate a payment already exists and works. What determines whether an SMB loses money is whether the authority granted to the agent is bounded, whether the approval is real, and whether the evidence survives an audit. The four points below are the ones to take into your next finance meeting.
- Tier the sign-off by amount. Auto-pay below a small cap, one approver in the middle, two approvers above a hard limit.
- Enforce thresholds, caps, velocity limits and allowlists in the payment gateway, not in the prompt, because the model cannot be the control.
- Generate idempotency keys before the first call and reuse them on every retry, or a timeout will become a duplicate payment.
- Reconcile every agent payment to an approved request, run an exception queue with owners and clocks, and keep an immutable log of the mandate, the reasoning and the approval.
What's actually useful in AI, every Friday
We follow everything happening in AI and send what's worth your time: new models, AI agents, and how to put them to work. One email a week, unsubscribe anytime.



