AI budget alerts aren’t enough: put agent policies guardrails to work

AI budget alerts report spending. Policies need tooling that can act inside ongoing agent work, connecting executive intent to practical guardrails.

Connections

An AI budget alert arrives. Someone needs to read it and decide what to do. Meanwhile, the coding agent keeps working.

Suppose a developer’s project is nearing its AI budget. Leadership wants experimentation to continue, but with limits on expensive models. An alert can report the spending. Implementing that decision requires a tool that can change which models the agent uses.

This is the gap that interests me: the distance between knowing what has happened and being able to act on it.

A budget does not have to be a stop sign

Imagine an agreed policy for that project. At 50 per cent of the budget, the developer receives a notification. At 70 per cent, their manager is informed. At 100 per cent, nothing further happens: leadership has explicitly allowed spending beyond the allocation. At 120 per cent, work moves to a cheaper model where a suitable alternative exists.

A policy response inside the developer’s workflow: continue with a cheaper model or request an exception after exceeding the project budget.

A policy response inside the developer’s workflow: continue with a cheaper model or request an exception after exceeding the project budget.

The developer needs to understand the change. A different model can affect the results. The explanation should appear where they are working, together with a way to request an exception when the task needs the more expensive model.

Being over budget does not automatically mean being out of control. The organisation can accept additional spending for work it considers worthwhile. The policy defines how that decision takes effect.

This is what I mean when I say that policies are decisions made once. We agree the recurring response, including when a fresh judgement is needed. We should not have to improvise it every time an alert arrives.

In my top-down FinOps workshop, we follow four steps: executive intent, strategic policies, tactical policies and implementation. In this example, the intent is to keep experimentation moving within agreed financial conditions. The thresholds and actions carry that intent into the developer’s work.

An agent can remain within budget while making more tool calls, running longer or accumulating more context than the organisation is prepared to allow without review. Available budget does not give every pattern of usage permission to continue.

Policies can set limits on those conditions and define what follows, such as pausing the run or requesting a review. Crossing a limit does not prove that the work lacks value. It identifies the point at which the organisation has decided that another judgement is needed.

The tool needs to reach the work

A developer gives an agent one task. That task can generate many model requests, tool calls and repeated attempts. The agent may delegate work to another agent. The activity can also start from an event, without a person typing a prompt.

I call this connected activity the AI flow. A policy needs to apply as that activity develops. If one response takes the project beyond a threshold, the system needs to check the updated position before the next relevant request.

That requires a short feedback loop. For agents making successive requests, checks performed hours later may miss the opportunity to influence the work. The response needs to happen in real time or near real time.

It also requires context. The same developer might have a team allowance and access to a separate project budget. Metadata must connect each request to the allocation and policy that apply, including when another agent takes over part of the task.

Infrastructure controls remain useful, but they cannot perform every action this policy needs. Changing a model requires access to model selection. Managing context requires an understanding of how context is used. Reporting the cost alone provides neither capability.

That is what I mean by AI-native tooling. It understands elements such as prompts, tokens, models and tool calls, and provides ways to act on them. It complements cloud controls by reaching into the AI activity itself.

The same connection matters when strategy changes. If leadership reduces the project’s funding, revised policies need to affect continuing work promptly. Otherwise, agents keep spending according to a decision the organisation no longer holds.

Why Stacklet’s direction interests me

This is why I welcome Stacklet’s Token Custodian announcement. Stacklet describes policies for budgets and model routing, alongside limits on agent steps, execution time and context growth. Those limits can trigger actions such as pausing a run, notifying its owner or starting a workflow. The scope extends from governing expenditure to governing usage as it happens. Token Custodian

The alignment with top-down FinOps is what interests me. Leadership decides where spending is justified. The practitioner translates that intent into implementable policies. The tooling makes those policies effective while the work continues.

Counting tokens cannot establish whether the work is valuable. That judgement remains with the organisation. But once the decision is made, suitable tooling should allow it to operate without repeated manual intervention.

Take one AI policy your organisation has agreed. When its conditions are met, can your tools carry out the response inside the ongoing work?

Or does the decision come back to someone reading an alert?