Cost Controls for AI Agents — Daily Cap + Circuit Breaker

Why Cost Controls Matter for AI Agents

Claude API calls scale with token usage, and agents make multiple sequential calls to complete tasks. A single malformed prompt or infinite loop can cost $50–$500 before you notice. Daily caps and circuit breakers prevent surprise bills by enforcing spending boundaries at runtime.

These controls are essential if you're running agents on a schedule, handling user-generated inputs, or deploying to production without constant supervision. They're not optional guardrails—they're infrastructure.

Daily Spending Cap Pattern

A daily cap tracks cumulative token costs from the start of your billing period (usually UTC midnight) and rejects new agent invocations once the limit is reached. Store this in Supabase as a simple row per agent with a `daily_limit` and `spent_today` field.

Query the spending at request time, add the estimated cost of the next call, and compare against the cap. If exceeded, return early with a cost-exceeded error instead of calling Claude.

const checkDailyLimit = async (agentId: string, estimatedTokens: number) => {
  const { data } = await supabase
    .from('agent_costs')
    .select('spent_today, daily_limit')
    .eq('agent_id', agentId)
    .single();
  
  const projectedCost = data.spent_today + (estimatedTokens * 0.003);
  if (projectedCost > data.daily_limit) {
    throw new Error(`Daily limit of $${data.daily_limit} exceeded`);
  }
};

Circuit Breaker for Spike Detection

A circuit breaker monitors the *rate* of cost increases, not just totals. If spending jumps 10x in a single request or 3x within an hour, the breaker trips and halts agent execution for a cooling-off period (30 minutes to 2 hours).

This catches runaway loops or prompt injection attacks faster than a daily cap alone. Store the last 10 request costs and compute a rolling mean; trip the breaker if any new cost exceeds `mean * threshold`.

Storing Costs in Supabase

Create a `cost_logs` table with columns: `id`, `agent_id`, `request_id`, `tokens_used`, `cost_usd`, `created_at`, `breaker_tripped` (boolean). Log every API call, even failed ones. This gives you exact audit trails and makes debugging cost spikes trivial.

Add a trigger or cron job (Supabase Edge Functions or Next.js API route) to reset `spent_today` each UTC midnight. Query cost_logs grouped by date to report weekly spend trends.

Integrating with Claude Agent Loops

Call `checkDailyLimit()` and `checkCircuitBreaker()` before each `anthropic.messages.create()`. Wrap your agent loop in a try–catch that logs costs immediately after each response. Use `response.usage` fields (`input_tokens`, `output_tokens`) to compute real costs.

Pass the `request_id` to both Claude (via system prompt context) and your cost log so you can correlate slow/expensive requests with specific agent runs.

Open-Source Implementation

The Pantheon project (github.com/lewisallena17/pantheon) provides a production-ready reference implementation of daily caps and circuit breakers for multi-tenant AI agent systems. It includes Supabase schema migrations, Next.js middleware for cost checks, and a dashboard for real-time spend visualization.

Fork or clone the repo to see cost tracking, alerting, and recovery strategies in action. The code is designed for indie teams and small startups running Claude agents at scale.

Open-source implementation

Everything in this article runs in pantheon — a production-ready Next.js + Supabase + Claude starter. Clone it, deploy to Vercel, run PM2. The dashboard auto-commits every agent edit and reverts itself if TypeScript breaks.