← Go back

Guide // MandateGuard

ALLOW, DENY or REQUIRE_APPROVAL: how agent spend decisions work

By the Ingenious AI team · Published 2026-11-14 · Reviewed 2026-11-14

▸ Run the free live demo See pricing

Free covers 1 agent and 1 policy with the full authorize flow, signed receipts and the approval inbox — no card required to start.

Short answer

Every MandateGuard authorize call ends in exactly one of three decisions. ALLOW means the request fits the mandate — caps, allowlist and threshold — and the spend may proceed. DENY means it breaks a hard bound: over the per-task cap, over the daily cap, vendor not allowlisted, or the agent is frozen; the reason is named and the attempt is receipted. REQUIRE_APPROVAL means the request is legal but above the human threshold, so it waits in the inbox until a person decides. Each decision is written to the hash-chained receipt ledger with vendor, amount and task reference.

What is an authorize decision?

An authorize decision is the policy engine's verdict on one proposed spend, returned by the authorize endpoint before money moves. MandateGuard renders it from the agent policy: per-task cap, per-day cap, vendor allowlist, approve-over threshold and frozen state. The decision is data the agent can act on programmatically — proceed, stop, or wait — and it is simultaneously a signed receipt, so the same verdict serves operations in the moment and audit later.

ALLOW: inside every bound

ALLOW is the quiet success case. The vendor is allowlisted, the amount fits under the per-task cap, the day still has room, and the amount sits at or below the approval threshold. The engine returns the decision with its receipt — sequence number, hash and signature — and the agent may complete the purchase. Operators should resist the urge to ignore ALLOW receipts because they are routine. In aggregate they are the spending history of the agent: the baseline of vendors, amounts and task references that makes anomalies recognisable. Vendor trust scores on paid plans are computed from exactly this history, counts of allowed and denied decisions per vendor, from your own ledger and nobody else's data.

DENY: a hard bound, named

DENY always carries its reason, because the remedy differs by cause. Over the per-task cap means the purchase itself is too large: split it, shrink it or escalate to a human process. Over the daily cap means today is spent: wait for tomorrow or ask an owner to reconsider the budget deliberately. Vendor not allowlisted means the counterparty is out of scope: the agent should use an approved vendor, and owners should review whether the attempt was discovery or steering. Agent frozen means the kill-switch is engaged and every request will be refused until an owner unfreezes. In all four cases the attempt is receipted with the amount the agent tried to spend, which preserves the size of what the mandate prevented.

REQUIRE_APPROVAL: legal, but a human decides

The third state exists because not every consequential spend is against the rules. A request above the approve-over threshold but inside the caps returns REQUIRE_APPROVAL, creates a pending item in the inbox, and notifies your webhook if one is configured. Approval mints a one-time spend token bound to the vendor and amount; denial closes the request. Either outcome extends the receipt story. Well-built agents treat this state as a normal branch, not an error: they park the task, tell their operator a purchase is waiting, and continue with work that does not need the money. Agents that treat it as failure and retry will generate repeated pending items and receipt noise, which is itself diagnostic.

The order of checks and why reasons stay honest

A request can break several bounds at once — too large, wrong vendor, day exhausted — and the engine's evaluation order determines which reason is reported. MandateGuard evaluates the policy as a whole and stamps the decision with the reason for the refusal that applies, keeping the receipt truthful about the mandate's state rather than the agent's hopes. For operators, the practical lesson is to fix reasons in order of scope: a frozen agent explains every denial until it is unfrozen; an allowlist gap explains denials for that vendor at any amount. Reading receipts with the policy in hand turns a pile of verdicts into a short list of actual decisions to make.

Designing agent behaviour around the three answers

Agents should be built with an explicit branch per decision. On ALLOW, proceed and record the receipt reference against the task so your own logs join up with the chain. On DENY, stop spending on that line, surface the reason to the operator, and never retry the identical request in a loop — the mandate will not change its mind between identical calls, and repeated denials only bury the signal. On REQUIRE_APPROVAL, wait without polling aggressively and resume only with the redeemed token. These behaviours sound obvious, yet most agent spending incidents trace back to a missing branch: an agent that only understood success kept improvising until it found a purchase the world allowed and the mandate would have refused.

Decisions as an audit surface

Because every decision is hash-chained, the three answers become a verifiable narrative: this agent, under this mandate, attempted these spends, and the engine answered thus. Verify-chain recomputes the ledger from stored rows and reports whether it is intact. Evidence export on paid plans packages receipts and the chain verdict for auditors, insurers or a finance team asking hard questions after an incident. The design point is worth stating plainly: the decision log is not exhaust from the system. For a business giving software the power to spend, the decision log is the product's memory of every moment that power was exercised or refused.

Five actions to take now

  1. Branch agent code explicitly on ALLOW, DENY and REQUIRE_APPROVAL
  2. Log the receipt sequence and hash against your own task records
  3. On DENY, read the reason before changing anything — cap, day, vendor or frozen
  4. Never retry an identical denied request in a loop
  5. Run verify-chain regularly so the decision history stays provable

Worked example: four calls, three answers

The MandateGuard live demo builds a policy with a per-task cap of 50 dollars, a daily cap of 100 dollars, approve-over at 25 dollars and an allowlist of openai and aws, then fires four requests. Twelve dollars and forty cents to openai returns ALLOW, within caps and allowlisted. Ten dollars to an unknown shop returns DENY, because the vendor is not allowlisted — the small amount does not save it.

Eighty dollars to aws returns DENY for breaking the per-task cap, even though aws is a legitimate vendor. Forty dollars to aws returns REQUIRE_APPROVAL: legal in every respect, but above the 25-dollar human line. Four calls demonstrate the complete grammar of the system, and each leaves a receipt in one chain that the demo lets you verify — the same grammar your own agents will meet in production.

Frequently asked questions

Does DENY ever come with a path to proceed?

Only by changing the facts: a different vendor, a smaller amount, a new day, or an owner changing the policy or unfreezing the agent. The identical request gets the identical answer.

Is REQUIRE_APPROVAL a soft DENY?

No. It is a pause with a human decision at the end of it. Approval releases a bound, single-use token; denial closes the request.

What does the agent receive with each decision?

The decision, the reason, and the receipt data including sequence and hash, so agent-side logs can reference the chain entry for the spend.

Can a decision be edited afterwards?

No. Receipts are hash-chained; editing a stored amount, vendor or decision breaks chain verification at that sequence number, which the verify endpoint reports.

Which decision do frozen agents get?

DENY with the frozen state as the reason, for every request, until an owner unfreezes the agent.

Keep reading

Put the policy in force: spend envelopes · intent registry · approval inbox · how the proof works · all MandateGuard guides