Contextual Agentic

The Commit Boundary: Where AI Recommendations Become Enterprise Consequences

Controls placed at the start of an agent conversation check the wrong thing. The decisive check evaluates the exact action about to become real, at the moment it becomes real.

·7 min read

Written as at 5 August 2026.

commit-boundaryagentic-aisecurityaccounts-payable

For: enterprise architects and security leaders. The decision: where, exactly, the control that decides an agent’s action should sit.

The launch note, Why Enterprise AI Needs a Deterministic Shell, described a Probabilistic Core that interprets and proposes, wrapped in a Deterministic Shell that owns identity, authority, schema, state and commitment. It named the Commit Boundary as the place where that shell is decisive. This note locates it.

The dangerous step is rarely the one that moves money

Illustrative scenario: a fictional composite written to make the point concrete. It does not describe a real organisation, and its figures are not reported outcomes.

Consider a food distributor whose accounts payable team uses an agent to work the supplier inbox. On a Tuesday morning an email arrives from a refrigerated freight carrier, supplier S-4471. It says the carrier has changed banks and gives a new BSB and account number, with a letter on the carrier’s letterhead attached.

The agent reads the email, matches the supplier, checks that the letter’s ABN agrees with the vendor master, and updates the bank details. Two hours later the weekly payment run is prepared. S-4471 has three approved invoices: $62,140, $71,380 and $52,900. The agent schedules all three, $186,420 in total, to the new account. A finance officer approves the payment batch, which shows supplier names and totals, as she does every week. The email was not from the carrier.

The Australian Cyber Security Centre describes exactly this lure in its guidance on business email compromise: an email that asks for an invoice to be paid or for bank account details to be changed. Nothing the agent did was outside its role. Every control the organisation had was satisfied.

Animated diagram of the commit boundary. Three proposals arrive: issue a refund of 250 dollars, change a supplier's bank details, and close a duplicate ticket. Each is checked for a typed schema, identity, authority, policy, evidence and current state. The refund passes and is written to the systems of record. The bank-detail change passes identity and authority but its policy check demands a second human, so it is escalated. The duplicate-ticket closure is denied because its evidence is missing. Every outcome writes a row to the evidence record.
Figure 1. Every proposal takes the same route, and each outcome is recorded. Animated; shown as a still image if your device is set to reduce motion.

Controls at the start of the conversation check the wrong thing

Look at where the controls were. The agent authenticated when its session began. Its role allowed vendor maintenance and payment scheduling. Its system prompt said “verify any change to bank details”. A human approved the batch. A log recorded every call.

Each control evaluated something earlier than the effect. Authentication established who the agent was, not what it was about to do. The prompt asked the model to perform a verification it could only approximate by reading the attacker’s own letter. The approval screen showed a batch, not the fact that the destination account for $186,420 had been created that morning. The log will explain the loss well, afterwards.

This is Hardy’s confused deputy in modern form: a component with legitimate authority is steered by someone without it into using that authority on their behalf. The fix is not a better-worded prompt. It is a check placed where the authority is actually exercised.

The CAE reading: find the point where computation becomes consequence

In the Contextual Agentic Enterprise (CAE), Contextual Agentic’s architecture for governed AI agents, the Commit Boundary is the point where a proposal would become an externally observable effect: money moves, an authoritative record changes, an entitlement is granted, a binding message is sent.

Two consequences follow. First, the control that matters must evaluate the action as it will actually be committed, with its final parameters, at the time of commitment, because evidence goes stale, approvals age, policies change and parameters can shift between recommendation and execution. Second, everything before the boundary can be probabilistic and cheap to discard. The agent may read, interpret, draft and propose as freely as its context allows.

In the S-4471 case there are two boundaries, and the first is the dangerous one. Updating the vendor master changes an authoritative record that every later payment relies on. No money has moved, yet the meaning of the next payment run has been rewritten. Chapter 18 of the book looks at the same question for legacy systems, where the system of record keeps transaction authority. The agent can prepare a bank-detail change; the system of record, behind a deterministic check, decides whether it is committed.

Four questions that locate a Commit Boundary

Walk every tool call an agent can make through these questions, in order.

  1. Does it change anything outside the agent’s own working state? Drafts, plans and proposals held in the workflow are not commits. Discarding them costs nothing.
  2. Would anyone outside the workflow see it or rely on it? Another system, a person, a counterparty or a regulator. A vendor master record, a payment instruction, an email to the supplier: yes to all three.
  3. Can it be undone by deleting your own state? If reversing it needs a new action in someone else’s system, or someone else’s cooperation, it is a commit, and the reversal is a new action with its own authority.
  4. Does the check that governs it run on the path of that exact call? If the control lives in the prompt, the session start or a separate approval screen, the boundary exists but is not defended.

A yes to question 2, or a no to question 3, places a Commit Boundary. Question 4 tells you whether you have one or only a diagram of one.

Applied to S-4471: reading the email and drafting the change pass as pre-commit. The bank-detail update is a commit, and it should arrive at a deterministic check as a prepared change that carries its evidence, for example that the letter came in by email, that the account is new, and that no call-back to the number already on file has been made. The payment scheduling is a second commit, and that check should see that the destination changed within the last day. Neither is a judgement the model needs to make. Both are facts the shell can test.

How Commit Boundaries fail

The quiet boundary is missed. Teams guard the payment and forget the record change that redirects it. A record change can be the more consequential write, because later actions rely on it.

The check sees the conversation, not the payload. A policy evaluated when the agent was asked to “process supplier updates” says nothing about the account number it later wrote.

Other paths bypass it. The agent’s calls pass through the gateway, but the same service account can run the ERP’s bulk import. One unmediated write path is enough.

Everything is treated as a commit. If every read needs approval, reviewers stop reading, and the approval that matters gets the same glance as the hundred that did not.

What a runtime should do when it cannot tell whether a commit happened is a separate question, taken up in Checkpointing Is Not Rollback.

The Commit Boundary does not decide your policy. It will not tell you whether a bank change needs a call-back or a five-day hold; people with authority set that. It does not detect fraud by itself, and it cannot protect a supplier whose mailbox was compromised. It gives you one place, on the execution path, where those decisions are enforced against the exact action.

Who does what

Executives decide which effect classes may ever commit without a human, who owns each authoritative record an agent can change, and that approvals must show the action being authorised rather than a summary of it.

Architects design an inventory of every write path to each system of record, human and machine, and route agent-initiated effects through one mediated gateway. They keep the system of record as transaction authority and let agents submit prepared transactions to it. The gateway’s outcomes, and how it closes the Governance-to-Action Gap, are the subject of The Governance-to-Action Gap.

Engineers implement and test typed adapters that carry an idempotency key and evaluate the final payload at commit time. Negative tests prove that the agent’s credential cannot write vendor bank fields directly, and that a payment to a destination changed within the hold period is escalated.

Effect classes in accounts payable

Agent action Effect class Evidence that it committed Reversible?
Read vendor master and invoices None (read only) Not applicable Not applicable
Draft a bank-detail change None (workflow state) Draft identifier Yes, discard it
Update vendor bank details Authoritative record change ERP change document and record version In the record, yes; in its consequences, only if caught before the next payment
Schedule payment in the run Payment instruction Payment proposal identifier Until the file is released
Release the payment file to the bank Money moves Bank acknowledgement reference No; recovery depends on other parties
Email the supplier to confirm Binding external communication Message identifier No

Key takeaways

  • A Commit Boundary is the point where a proposal would become an externally observable effect, and the control that governs it must run there.
  • Controls at session start, in the prompt or on a summary approval screen evaluate something earlier than the action and can be satisfied by a harmful one.
  • Record changes that alter the meaning of later actions, such as supplier bank details, are Commit Boundaries in their own right and often the more dangerous ones.
  • The check at the boundary must evaluate the final payload at the time of commitment, since evidence, approvals and parameters can all change after the recommendation.
  • One unmediated write path is enough to make every other boundary control decorative.

Sources and further reading

  • The Contextual Agentic Enterprise, Chapter 3 (the Commit Boundary) and Chapter 18 (legacy integration and transaction authority).
  • Hardy, N., “The Confused Deputy (or why capabilities might have been invented)”, published in ACM SIGOPS Operating Systems Review 22(4), 1988, pp. 36–38. https://dl.acm.org/doi/10.1145/54289.871709
  • Australian Signals Directorate, Australian Cyber Security Centre, “What is business email compromise?” (accessed 22 October 2026). https://www.cyber.gov.au/threats/types-threats/business-email-compromise

Where the book takes this further

The book works through the Commit Boundary with the action gateway, the evidence that must accompany a consequential action, and a staged path for letting agents write to legacy systems as evidence accumulates. For what an agent should be shown before it proposes anything, see Context Is Not a Prompt; for what should be kept once it commits, see Evidence-First Decision Records.

This article is part of CAE Field Notes, a series accompanying the book, The Contextual Agentic Enterprise.

← All articles

Related