Blog

Why AI Agents Need Spend Policies, Not Just API Keys

An API key answers one question: is this request coming from who it claims to be? It says nothing about a second, entirely different question: should this specific request be allowed to happen at all?

For most API calls, that gap doesn't matter much. A read request either succeeds or fails, and the blast radius of getting it wrong is small. Spend is different. Every authorized transaction is a real-world commitment — a card charge, a vendor invoice, a cloud bill — and once it clears, it's not easily undone.

Prompts are not policies

A common first instinct is to constrain an agent's spending in its system prompt: "never spend more than $500," "only buy from approved vendors." This works until it doesn't. Prompts are:

  • Fragile — a jailbreak, a bad tool response, or an unusual edge case in the conversation can route around instructions that were never enforced anywhere but text.
  • Hard to audit — there's no queryable record of why a given spend was allowed, just a transcript to comb through after the fact.
  • Slow to update — changing a limit means redeploying the agent, not editing a rule.

None of this is a knock on prompt engineering. It's a mismatch of tool to job. Limits that matter belong in infrastructure, not in the text an LLM happens to read before deciding what to do next.

What a policy layer actually checks

A spend policy engine sits between the agent and the money moving, and evaluates every request against rules that are independent of the agent's own reasoning:

  • Per-transaction and daily/monthly limits
  • Allowed merchants and MCC (merchant category) codes
  • Currency and velocity (rate-limiting) controls
  • Business-hours restrictions
  • Thresholds that require a human to sign off before anything clears

Crucially, this evaluation happens in the request path, before the spend is authorized — not as a post-hoc audit of what already happened.

Audit trails are the other half

Authorization alone isn't enough if you can't later reconstruct what happened and why. Every decision — approved, declined, or escalated to a human — should be logged with the full rule evaluation that produced it: which policy fired, which limit it checked against, and the exact state of the request at that moment.

That combination — real-time enforcement plus a complete, queryable audit trail — is what separates a policy engine from a prompt instruction. One is enforced by infrastructure; the other is enforced by hope.