LLM Cost Control for Agents: 5 Guardrails to Limit Spend

A healthy 12-step agent run on Claude Sonnet 5 costs about $0.39. The same agent stuck in a 200-step loop costs about $74, because its context grows 1,800 tokens a step and every step re-sends all of it: 36.7 million input tokens in total. On Claude Opus 5 or GPT-5.5 the same loop is about $185. Five guardrails stop this: max_tokens per call, a step cap per run, an explicit stop condition, a per-run dollar budget computed from the usage fields on every response, and a per-day cap in the vendor console.

The first three are one line each. The fourth is the 30-line runner below. The fifth is a console setting. Do all five, because each catches a failure the others miss.

Agents do not usually fail by producing one huge response. They fail by taking one small, reasonable-looking step over and over. The failure modes we see most often:

• A tool that returns an error message the model treats as a prompt to try again, with the same arguments, forever
• A "verify your work" instruction that the model satisfies by re-running the whole task
• A search tool that returns slightly different results each call, so the model never feels done
• Two agents handing a task back and forth, each believing the other is responsible for finishing
• A stop_reason of max_tokens that the loop code treats as "call again" instead of "something is wrong"

None of these look expensive on step 5. They look expensive on step 80, when the context is 147,000 tokens and each step costs more than the first twenty combined. The mechanics of that growth are in [how much an AI agent costs to run](/guides/how-much-does-an-ai-agent-cost-to-run).

Reference trace: 4,000-token prefix, 500-token task, each step adds a 300-token tool call and a 1,500-token result. Input at step k is 4,500 + 1,800 × (k − 1). Summed over 200 steps: 200 × 4,500 + 1,800 × 19,900 = 36,720,000 input tokens. Output is 200 × 300 = 60,000 tokens. Context at step 200 is 362,700 tokens, which fits a 1M window; a 200K model such as Claude Haiku 4.5 would error out around step 109, which is an accidental guardrail, not a plan.

Seventeen times the steps, roughly 190 times the cost. With prompt caching (cache reads at roughly 10% of list, writes at roughly 125% on Anthropic), the Sonnet 5 loop becomes 362,700 × $2.50 + 36,357,300 × $0.20 + $0.60 = about $8.78. Caching is worth having, as [prompt caching for AI agents](/guides/prompt-caching-for-ai-agents) shows, but 22 times a healthy run is still a bill you notice.

1. max_tokens per call. Size it for the step, not the model's ceiling. A tool-calling step needs 512 to 2,048 tokens; a final report might need 4,000. One runaway 32,000-token response on Opus 5 is 32,000 × $25 = $0.80 by itself, and it then sits in context for every later step.

2. Max steps per run. Pick a number from your traces: the p95 of successful runs plus a margin. For most tool loops that is 15 to 30. A run that hits the cap should fail loudly, not silently return whatever it had.

3. An explicit stop condition. Give the model a finish or report tool and end the loop when it is called or when stop_reason is end_turn. Also detect degenerate progress: the same tool called with the same arguments twice in a row is a loop, and the run should abort.

4. A per-run USD budget from usage. Every response reports input, cached and output tokens. Multiply by the model's rates, accumulate, and abort when the total passes the cap. This is the only guardrail whose threshold is in the unit you actually care about.

5. A per-day account cap in the vendor console. Anthropic and OpenAI let you set spend limits per workspace or project with alerts; Google Cloud budgets alert and can be wired to stop spend. This is the backstop for the bug you have not thought of yet.

SDK clients retry rate limits and server errors by default, usually two or three attempts with exponential backoff. A rejected request is generally not billed, but a request that times out after generation has started often is, and an application-level retry of a step re-sends the whole context again.

At step 100 of the reference loop the context is 4,500 + 99 × 1,800 = 182,700 tokens. One attempt on Sonnet 5 uncached is 182,700 × $2 = $0.37; three attempts are $1.10 for zero progress. Cached, each attempt is roughly $0.04. Two rules follow: keep the SDK's retry count, never wrap it in your own retry loop, and if you must retry a failed run from scratch, count it against the same per-run budget rather than starting a fresh one.

This Python runner drives a Claude tool loop and stops when either the dollar cap or the step cap is hit. The same shape works on OpenAI with responses.create and usage.input_tokens_details.cached_tokens.

from anthropic import Anthropic

PRICES = {"claude-sonnet-5": (2.0, 2.5, 0.2, 10.0)}  # $/1M: input, cache write, cache read, output

class BudgetedRunner:
    def __init__(self, model, system, tools, budget_usd, max_steps=25):
        self.client, self.model, self.system, self.tools = Anthropic(), model, system, tools
        self.budget, self.max_steps, self.spent = budget_usd, max_steps, 0.0

    def cost(self, u):
        i, w, r, o = PRICES[self.model]
        return (u.input_tokens * i + (u.cache_creation_input_tokens or 0) * w
                + (u.cache_read_input_tokens or 0) * r + u.output_tokens * o) / 1e6

    def run(self, messages, execute_tool):
        for step in range(1, self.max_steps + 1):
            resp = self.client.messages.create(model=self.model, max_tokens=1024,
                system=self.system, tools=self.tools, messages=messages)
            self.spent += self.cost(resp.usage)   # e.g. 24,300 in × $2 + 300 out × $10 = $0.052
            if self.spent > self.budget:
                raise RuntimeError(f"budget ${self.budget} exceeded at step {step}: ${self.spent:.3f}")
            messages.append({"role": "assistant", "content": resp.content})
            if resp.stop_reason != "tool_use":
                return resp, self.spent
            results = [{"type": "tool_result", "tool_use_id": b.id,
                        "content": execute_tool(b.name, b.input)}
                       for b in resp.content if b.type == "tool_use"]
            messages.append({"role": "user", "content": results})
        raise RuntimeError(f"step cap {self.max_steps} hit after ${self.spent:.3f}")

Set budget_usd from your traces: three times the median successful run is a reasonable start. For the Sonnet 5 reference run that is about $1.20, which the 200-step loop would hit at step 24, roughly $73 before the console would notice.

A budget stops one run. Alerting tells you that runs have started needing it.

• Log cost per run, not per call, with the model, step count and stop reason
• Tag every run with the feature or customer that triggered it, so a spike has an owner
• Alert on the p99 cost per run and on the share of runs that hit the step cap or the budget; both climbing together means a new failure mode, not a busy day
• Reconcile weekly against the vendor's usage report, because a runner bug that under-counts tokens is itself a runaway

If you route through OpenRouter, per-key credit limits give you a second, vendor-independent cap; the trade-offs are in [OpenRouter vs direct API](/compare/openrouter-vs-direct-api).

Guardrails bound the damage; model choice sets the slope. For a well-specified loop, DeepSeek V4 Flash ($0.05 / $0.16) turns the 200-step disaster into a $1.85 annoyance and Gemini 3.8 Flash ($0.75 / $3.75) into $28. In our experience both are reliable at structured tool calls when the task is clear, and the [Gemini agent API cost](/guides/gemini-agent-api-cost) article covers the Gemini side.

Pay for Claude Sonnet 5, GPT-5.4 or a flagship when the task is ambiguous or the loop is long, because those are the runs where a cheap model is most likely to wander and wandering is what the table above prices. Whatever you pick, the runner above works unchanged; only the PRICES row differs. Price your own trace in the [calculator](/calculator), and see [Claude agent API cost](/guides/claude-agent-api-cost) for the per-vendor usage fields.