An AI agent doesn’t cost what a single ChatGPT query costs. It costs what a chain of queries costs: the agent thinks, calls a tool, reads the result, thinks again, calls another agent, that sub-agent repeats the cycle. Every step is a model call, and every call drags along the full context accumulated up to that point. If nobody sets a limit, cost doesn’t grow linearly — it grows with the depth and width of that chain.
Why the bill spikes without anyone noticing
Large companies with full technical teams have ended up with seven-figure AI compute bills without ever consciously deciding to spend that much. It wasn’t an attack or an exotic misconfiguration. It was the sum of reasonable decisions — «let the agent retry if it fails,» «have it check with a second agent to validate,» «keep the full history in case it’s needed» — that together generate consumption nobody was measuring in real time. The billing dashboard arrives at month-end, not mid-task.
The five places where control gets lost
- Unlimited retry loops: an agent that retries a failed task indefinitely, with no retry cap or backoff, can burn through budget in minutes.
- Sub-agent fan-out: an orchestrator agent that delegates to 3, 5, or 10 sub-agents in parallel multiplies consumption at every level of the hierarchy, and that multiplier is rarely calculated before the system goes to production.
- Context dragged along in full: every new call resends the entire conversation or task history. Without a summarization or context-pruning mechanism, cost per call keeps climbing even when the task hasn’t changed.
- No real rate limiting: limits set at the API-key level, not at the agent or use-case level, won’t stop a single agent that entered a costly loop.
- Zero real-time cost visibility: if the only place you see spend is the provider’s invoice, it’s already too late to react.
How your B2B SMB sets limits this week
You don’t need Fortune 500 infrastructure to operate with control. You need four concrete things:
- A hard budget cap per agent and per task, configured as a real stop, not an alert someone can ignore.
- A cap on retries and sub-agent depth defined in code, not left to the model’s judgment.
- Model-to-task matching: use the cheapest model that solves the step — not every step in a flow needs the most expensive model. Reserve the top-tier model for reasoning that actually requires it.
- A per-agent cost dashboard, reviewed weekly, not just the provider’s monthly invoice. If you can’t see what each flow spends, you can’t optimize it.
The opportunity behind the risk
SMBs that build these limits in from the design stage don’t just avoid the surprise bill: they end up with faster, easier-to-debug systems, because an agent with clear limits fails predictably instead of silently degrading. AI automation is still a real competitive advantage for a B2B company — but only if whoever implements it understands that an ungoverned agent isn’t a tool, it’s an uncapped variable expense.
