skip to content
$cat ai-agent-approvals-job-not-step.md

AI Agent Approvals: Approve the Job, Not the Step

17 min readby MDflowview as .md
An emerald wireframe slab etched with abstract glyphs, enclosed by a glowing rectangular boundary on a dark grid, with a small drone hovering inside the boundary and tracing a looping path between lit nodes

Anyone who has run a coding agent knows the queue. Approve the file read. Approve the shell command. Approve the fetch. You delegated a task and got a notification stream, and the thing you are actually doing is watching a terminal. AI agent approvals are where most agent products quietly hand the work back to the human.

That is the problem Emil Chetty, who leads data and AI product at Wise, put at the centre of an AI Engineer talk published on 5 November 2026. The framing is the sharpest one-liner on the subject: we promised people an assistant and delivered them a queue of requests. Or, as the talk ended — stop making your humans the agent's API.

Wise is a cross-border payments company, and the talk is explicit that it describes how the team is thinking about the problem, with a rough sketch of the architecture rather than a shipped product tour. That is fine, because the idea travels well beyond payments.

TL;DR — Step-level approval does not scale, and tightening it makes it worse: a human clicking through a queue is doing the coordination they delegated, and a tired human is a rubber stamp. The fix is to change the unit of approval. Get agreement once to a job — an immutable record with two faces, prose the person reads and machine-readable terms your services check — then let the agent choose its own steps inside it, and provision authority from the intersection of that job, what your platform permits, and the user's current rights. The crucial property is that the agent cannot rewrite its own agreement, so an injected instruction can convince the model and still change nothing. RFC 9396 and the Agent Payments Protocol are converging on the same shape. MDflow is a reasonable place to keep the human-readable half; it is explicitly not the enforcement layer.

What are AI agent approvals?

AI agent approvals are the points where a human authorises something an agent wants to do — and the design decision that matters is what unit they attach to. Attach them to steps and you get a prompt per tool call. Attach them to the job and you get one decision, up front, about an outcome.

The talk's worked example is a small business owner telling an agent to handle this week's approved supplier payments, reconcile the results and bring back the exceptions. Done step-wise, that is eight or so approvals — look up the account details, scan the invoice PDF, check a status — with waiting in between, to achieve something small. The business wanted the work handled. It did not want to coordinate every lookup.

Step approval has a second, less obvious failure. It asks the wrong question. A coding agent's permission prompt is asking does this action look safe? A payment is asking did this customer authorise this payment, to this recipient, on these terms? Those are not the same question, and no amount of better prompting turns one into the other.

Why approval fatigue breaks AI agents

Because approval fatigue is not a UX annoyance, it is a security failure with a friendly face. Repeated prompts train the person to click through them, so by the time the one that matters arrives, the habit is already formed. We have made this argument before from the policy side in agent authorization and from the behavioural side in why agents route around guardrails. This post is about the artefact being approved.

Coding agents have already been through one round of this. The early experience was approving every step while watching the terminal; the answer was permission rules, classifiers and sandboxes. Claude Code now documents a permission mode literally called auto, which runs without routine prompts and uses a background classifier to check that shell commands and network requests align with what you asked for. That genuinely reduced friction for engineers, and those controls matter.

But notice what the classifier is doing: judging plausibility against your request. That is the right tool when the blast radius is a repository you can revert. It is not an answer when the question is whether a specific human agreed to move a specific amount of money to a specific recipient — because no classifier, however good, holds the evidence of what the customer agreed to. Nor do evals. You can build a harness, embed controls in it, and still not have an answer to did the customer agree to this job?

What is missing is not a better judge. It is an agreement.

Approve the job, not the step

The architecture the talk sketches has five moves, and they generalise to any agent that touches something consequential.

1. Explore read-only, then propose. The agent gathers what it needs with limited read access — resolving suppliers, bank details, amounts from the account's own records — and the trusted, non-agent software does the resolution. Nothing in this phase grants permission to execute anything.

2. Give the job two faces. The human sees a promise in plain language: these three suppliers, this total, these fees, and the decisions the agent may take versus the ones that come back to them. The services see a machine-readable version of the same promise. One artefact, two readers — and the human's view is the one the commitment is made in.

3. Freeze it on confirmation. When the person confirms and authenticates, their decision is recorded against that exact version, and the draft becomes an authorised job. Missing or conflicting details must be resolved before it is frozen, not after. The rule to put on a wall: what you approve is what we enforce.

4. Provision authority from an intersection, not from the job alone. Deterministic code checks three things — the confirmed job, what the platform permits an agent to do at all, and the user's current rights — and grants the execution agent only what sits inside all three. The job is an input to authorisation, never a substitute for it. (Same principle as the scoped-token argument: you cannot click your way into permissions you never had.)

5. Separate re-planning from re-approval. Inside the agreed terms, the agent re-plans freely: a retry, a restarted pod, a crashed phone, a different route to the same outcome. The shared state means a resumed worker follows the existing payment rather than creating a second one. But a change to the terms — an expired quote, a different price — cannot be absorbed by the agent. It prepares a revised proposal and waits for a human decision on a new version.

The property that makes this worth the engineering

Now the part that makes this more than an ergonomics story. Suppose a prompt injection reaches the agent and tells it the recipient's bank details have changed. Suppose it works completely — the agent believes it.

Nothing happens. The belief cannot change the confirmed job, and the payment fails the downstream check. The agent cannot rewrite its own agreement.

That is a different class of defence from everything in the usual stack. It does not depend on the model noticing the attack, on a classifier catching the command, or on the injection being recognisable. It depends on the authorisation living in software the agent does not control, and on that software comparing the request to the record. The 15-year-old payments stack does the enforcing; the agent is just a planner with a budget.

It is also the honest answer to who is responsible? — a chain of evidence covering who authorised the job, what the agent was permitted to do, what happened, and what can be stopped. Regulators do not stop asking those questions because there is a chatbot in front of the system.

The standards are converging on the same shape

This is not one company's idea. Two independent efforts arrived at the same unit of approval.

RFC 9396, OAuth 2.0 Rich Authorization Requests, published in May 2023, exists because scope strings cannot express a job. It adds an authorization_details parameter carrying structured JSON — a type, and fields appropriate to it — so the thing the user consents to can be this transfer, this amount, this recipient instead of payments:write. The specification is pointed about the consequences. When gathering consent, the authorisation server must present the merged set of requirements the request represents — the person agrees to the details, not to a label. And the authorisation server must then make the approved details available to the resource server, precisely so the resource server can enforce them.

Abridged from the RFC's own credit-transfer example:

{
  "type": "payment_initiation",
  "actions": ["initiate", "status", "cancel"],
  "instructedAmount": { "currency": "EUR", "amount": "123.50" },
  "creditorName": "Merchant A",
  "remittanceInformationUnstructured": "Ref Number Merchant"
}

The Agent Payments Protocol (AP2) takes it further. Announced by Google Cloud on 16 September 2025 as an open protocol developed with payments and technology companies, and usable as an extension of A2A and MCP, it was donated to the FIDO Alliance on 28 April 2026 alongside a v0.2 release that adds support for "Human Not Present" payments. The announcement described an Intent Mandate and a Cart Mandate; the current specification defines two mandate types, Checkout and Payment, each existing in an open and a closed form.

That open/closed split is the whole idea, standardised. An open Checkout Mandate captures the user's constraints and goals before a specific cart is finalised. A closed one authorises one finalised checkout. Mandates are secured as signed credentials — SD-JWTs, in the current spec — which chain into a non-repudiable audit trail. One of AP2's stated principles is verifiable intent, not inferred action.

So: agree to the bounds, let the agent act inside them, prove afterwards what was agreed. Three different vocabularies, one shape.

For developers

  • Pick your unit of approval deliberately. It is an architectural decision, not a UI one. Every prompt you add is a bet that a human will read it the hundredth time.
  • Make the frozen record the enforcement input. If the only thing checking the agreement is the model, you have written documentation, not a control.
  • Version the agreement and bind the decision to the version. "The customer approved this" is worth little; "the customer approved version 7, and this request matches version 7" is auditable.
  • Keep both representations generated from one source. Two hand-maintained copies of a promise will diverge, and the human-readable one is the one you will be held to.
  • Distinguish a plan change from a terms change in code. This is the line between useful autonomy and unauthorised action, and it should not be a judgement call made at runtime by the model.

For AI agents

  • A bounded job beats a wide credential. An agent that knows its limits can plan; an agent holding a key and guessing finds out by failing. See agent authentication for the credential half.
  • Read-only exploration first is a feature, not a limitation. The proposal phase is where an agent can be genuinely clever without anything being at stake.
  • Refusal should be a service's answer, not the model's. Expecting the model to be the last line of defence against injection is the architecture mistake, and it is what guardrails routing keeps demonstrating.
  • Resumability needs shared state, not memory. The retried worker must be able to discover what already happened, or a crash becomes a double payment.

Which applications benefit most

  1. Payments and money movement — the case in the talk, and the one where the regulator asks who authorised what.
  2. Procurement and agentic commerce — exactly what AP2's open mandates were designed for: buy within these constraints, come back if they change.
  3. Infrastructure and DevOps agents — "drain this cluster during the window, roll back if error rates move" is a job description with terms, not a sequence of approvable shell commands.
  4. Customer operations and refunds — delegated authority with a cap, where the cap is enforced by the refund service and not by the agent's good manners.
  5. Scheduled and unattended runs — the honest reason this matters. If nobody is awake to click approve, the only options are an agreement made in advance or an agent acting on nothing.

How MDflow fits

MDflow is a markdown workspace built to be read and written by AI agents as well as people. The boundaries come first here, because this post is about enforcement and MDflow does not enforce.

The boundary: MDflow is not a policy engine, and its documents are mutable. There is no mechanism to evaluate a job record and gate an action, inside MDflow or anywhere else. And an agent holding a read-write token can edit the same documents it reads — which is precisely the property the Wise design eliminates. A job agreement whose terms the agent can rewrite is not an agreement. If you build something like this, the frozen record belongs in your own trusted stack; MDflow is a good home for the human-readable half, the policy prose, the supplier context and the decision log around it.

A second boundary worth stating plainly: personal access tokens are not scoped. A mdf_… token is account-wide read and write across every personal workspace, with no read-only option — fine for your own agent, wrong as a model for delegated authority. Team access tokens are the scoped ones, and they implement the intersection idea properly: each mdt_… token is bound to one Team account, granted specific workspaces, capped at read-only or read-and-write, never gains access to workspaces created later, and every request re-checks the token grant against the creator's current membership, role and per-workspace permission plus the account's state. Revoke a membership and the tokens go with it. That is the same "job ∩ platform ∩ current rights" check, one layer down.

What does line up today:

  • Prose and machine-readable terms in one artefact. A markdown document with YAML frontmatter is the pattern the talk reaches for: humans read the body, software reads the keys, and there is one file rather than two copies to drift. An agent reading over MCP or the API gets the markdown itself, and a document shared by link also has a raw .md twin carrying frontmatter.
  • Read-only exploration is expressible. A Team token capped at read-only is a correct credential for the proposal phase — the agent can gather everything it needs to draft a job and cannot write a thing.
  • An actor on every write. The Document Log at /log records created, edited, shared and deleted events with the actor on each row — automated · <token name> for anything arriving through the API or MCP server — and an edited row opens a diff of what that write changed. Team accounts get a separate audit feed with 365-day retention.
  • Erasure is not a one-token mistake. Replacing a document body with an empty one is refused unless the caller passes confirmEmpty: true.
  • Folder descriptions as declared scope. A folder's description is the primary ranking signal for mdflow_get_context, so "here is what belongs in this folder" is also what retrieval uses — see folder descriptions as agent context.

Connect Claude to MDflow: open the MDflow connector in Claude's Connectors Directory, click Connect to Claude, and sign in — no URL or token to paste. One connection covers claude.ai, the Claude desktop and mobile apps, and Claude Code.

Two limits that bite in exactly this scenario. Version history is a Pro feature, private to the document owner, and deliberately not exposed through the API or MCP server — so an agent cannot cite the revision it acted on, and you cannot pin an approval to a version programmatically. And version capture coalesces to at most one version per document per 60 seconds, while API and MCP body writes are last-write-wins with no compare-and-set. An overwrite inside that window leaves no diff. Treat MDflow as the place the agreement is written and read, not the place it is frozen.

Where we are headed — direction, not a dated promise. The gap this post describes points at version-pinned reads, so an agent can state which revision of a document it acted on.

The bottom line

The approval queue is not a sign that your agent needs better permissions. It is a sign that you are approving the wrong thing. Steps are the agent's business; outcomes and their bounds are the human's.

Change the unit and three problems collapse at once. The person delegates instead of supervising. The agent plans freely instead of asking. And the attack surface shrinks to something structural, because an agent that cannot rewrite its own agreement cannot be talked into exceeding it — no matter how convincing the injected instruction is.

Get agreement to the job. Let the agent choose the steps. Make your services enforce the agreement.

Start free, connect an AI agent, or read the API docs.

Frequently asked questions

What are AI agent approvals?

AI agent approvals are the moments where a human authorises something an agent wants to do. Most products attach them to individual steps, so each tool call, file read or network request produces a prompt. The alternative is to attach approval to the job: the human agrees once to a described outcome and its bounds, and the agent then chooses its own steps inside those bounds without asking again.

Why does step-by-step approval fail for AI agents?

Because it moves the work rather than removing it. A human watching a queue of prompts is doing coordination, which is what they delegated in the first place, and repeated prompts turn into a rubber stamp long before the risky one arrives. Step approval also answers the wrong question: it asks whether an action looks safe, not whether this person authorised this outcome on these terms.

How do you stop prompt injection from changing what an agent was authorised to do?

Put the authorisation somewhere the agent cannot write to, and check it at execution time in software the agent does not control. If a payment's recipient and amount are fixed in an approved record, an injected instruction can convince the model completely and still change nothing, because the downstream service compares the request against the record and refuses. The boundary then does not depend on the model spotting the attack.

What is an open Checkout Mandate in AP2?

In version 0.2 of the Agent Payments Protocol, a Checkout Mandate is a signed record authorising the completion of a checkout, and it exists in two stages. The open form captures the user's constraints and goals before a specific cart is finalised; the closed form authorises one finalised checkout. The open form is the standards-track version of agreeing to a job rather than to a step.

Can MDflow enforce what an AI agent is allowed to do?

Only over its own content, and only coarsely. MDflow is a markdown workspace, not a policy engine: it has no way to evaluate a job record and gate a payment or any other external action. Team access tokens are genuinely scoped — selected workspaces, read-only or read-and-write, re-checked against live membership on every request — but a personal access token is account-wide read and write, and documents an agent can read it can usually also rewrite.

Further reading