How to Set Token Limits
on AI Agents.

Hard Cap vs. Soft Limit: The Critical Distinction

Most developers, when they first implement token controls, reach for the same pattern: a conditional check that logs a warning when a counter exceeds a threshold. This is a soft limit, and it is nearly useless for preventing runaway costs.

The fundamental problem is sequencing. When your code logs a warning — or even raises a Python exception after the fact — the LLM API call has already completed. The tokens have been consumed. The money has been spent. The warning is a notification that something expensive just happened, not a prevention mechanism.

In a looping agent context, this distinction is catastrophic. If your soft limit fires on call 101, you've already paid for all 100 calls before it. And if your exception handling is imperfect — if the loop catches and swallows the exception — your soft limit may never actually stop anything.

Hard caps terminate execution deterministically. The enforcement happens at the interception layer, before the API call is dispatched. No amount of LLM reasoning, exception handling variation, or framework quirk can override a hard cap — because the call never reaches the API in the first place.

The Three Types of Token Limits

Effective token control requires all three layers working together. Each addresses a distinct failure mode. Implementing only one or two leaves meaningful gaps.

llm = ChatOpenAI(
  model="gpt-4o",
  max_tokens=4096
)

# With SupraWall:
protect(agent, budget={
  "session_tokens": 100_000
})

protect(agent, budget={
  "daily_limit_usd": 10
})

Implementation Guide by Framework

Every major agent framework handles token limits differently. Native controls are inconsistent — some count iterations, some count wall-clock time, and most don't track cumulative spend at all. The following configurations show the correct approach for each framework, combining native controls with SupraWall's budget layer.

from langchain.agents import AgentExecutor
from suprawall.langchain import protect

# Native: max_iterations stops loops but doesn't track spend
agent = AgentExecutor(
    agent=llm_agent,
    tools=tools,
    max_iterations=25,        # stops after 25 steps
    max_execution_time=120,   # stops after 120 seconds
)

# SupraWall: adds dollar budget + token tracking on top
secured = protect(agent, budget={
    "daily_limit_usd": 10,
    "session_tokens": 200_000,    # 200K tokens per session
    "circuit_breaker": {
        "max_identical_calls": 5,
        "window_seconds": 30,
    }
})

from suprawall.crewai import protect_crew

secured_crew = protect_crew(
    crew,
    budget={
        "per_agent_daily_usd": 5.00,    # $5/day per agent in the crew
        "crew_daily_usd": 20.00,        # $20/day for the entire crew
        "session_tokens_per_agent": 50_000,
    },
    on_budget_exceeded="notify_and_pause"  # sends webhook before halting
)

import autogen
from suprawall.autogen import SupraWallGroupChatManager

# Native: max_turns counts conversation turns, not tokens
# This is insufficient — a single turn can consume 100K tokens

# SupraWall: token-aware enforcement
manager = SupraWallGroupChatManager(
    groupchat=group_chat,
    budget={
        "session_tokens": 500_000,    # total tokens across all agents in session
        "daily_limit_usd": 25.00,
    }
)

# Native: max_prompt_tokens and max_completion_tokens at run level
# These don't aggregate across multiple runs in a session

# Correct approach with SupraWall session tracking:
from suprawall.openai import SecureAssistantSession

session = SecureAssistantSession(
    assistant_id="asst_...",
    budget={
        "session_tokens": 200_000,  # across all runs in this session
        "daily_limit_usd": 15.00,
    }
)
response = await session.run("Analyze Q4 results")
# Session tracks tokens cumulatively across all runs

Monitoring and Alerting

Token limits without observability are incomplete. A hard cap that silently kills an agent in production — without notifying your on-call team — is nearly as bad as no cap at all. The correct configuration layers alerts at 50% and 80% of the budget before the hard 100% cutoff.

This gives your team two intervention windows: one to investigate whether the spend is expected, and one final warning to take action before the agent halts. SupraWall supports webhook delivery to any target — Slack, PagerDuty, custom endpoints.

secured = protect(
    agent,
    budget={
        "daily_limit_usd": 100,
        "alerts": [
            {"threshold": 0.5, "channel": "slack",     "webhook": "https://hooks.slack.com/..."},
            {"threshold": 0.8, "channel": "pagerduty", "webhook": "https://events.pagerduty.com/..."},
            {"threshold": 1.0, "action": "halt"},   # hard cap at 100%
        ]
    }
)

Each alert fires with a structured payload that includes the agent ID, current spend, daily limit, and session ID. This gives your team everything needed to locate and investigate the agent without manually querying API logs.

{
  "event": "budget_threshold_reached",
  "agent_id": "research-agent-v2",
  "threshold_pct": 80,
  "current_spend_usd": 80.00,
  "daily_limit_usd": 100.00,
  "session_id": "sess_xK7m9...",
  "timestamp": "2026-03-15T14:32:17Z"
}

Quick Reference

Native vs. SupraWall Controls by Framework

Related Resources

Frequently Asked Questions