“In 2012, a datacenter PAC compressor tripped and caused a thermal runaway. In 2026, an unhandled LLM 429 rate limit caused an autonomous subagent to loop 4,000 times in 3 minutes, burning $2,500 in tokens.”

During production deployment of autonomous AI agent workflows at Kyndryl, we discovered that treating LLM APIs like standard deterministic microservices is an operational trap.

Non-deterministic AI models experience transient API rate limits, provider outages, and hallucinated recursive loops. Without stateful Circuit Breakers, single subagent failures cascade across your entire orchestration pipeline.

The Circuit Breaker Pattern for LLMs

Just as electrical breakers trip to protect hardware, an Agentic Circuit Breaker monitors model endpoint error rates and transitions between three states:

• CLOSED (Normal): Traffic flows to the primary frontier model (e.g. Gemini 2.0 Pro).
• OPEN (Tripped): Consecutive rate limits (429) or 5xx errors exceed the threshold (e.g., 5 failures in 30s). Traffic immediately shifts to a local fallback endpoint or secondary provider.
• HALF-OPEN (Testing): After a cooldown timer (e.g., 60s), probe requests test provider recovery before restoring primary traffic.

[!IMPORTANT] Never allow an autonomous subagent to retry failed API calls without exponential backoff and maximum iteration caps (max_iterations = 10).

// # Production Agentic Circuit Breaker Implementation
class AgentCircuitBreaker {
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  ariaFailureCount = 0;
  private readonly threshold = 5;

  async execute<T>(taskFn: () => Promise<T>, fallbackFn: () => Promise<T>): Promise<T> {
    if (this.state === 'OPEN') {
      console.warn('> Circuit OPEN: Routing to Fallback Model');
      return fallbackFn();
    }
    try {
      const result = await taskFn();
      this.reset();
      return result;
    } catch (err) {
      this.handleFailure();
      return fallbackFn();
    }
  }

  private handleFailure() {
    this.ariaFailureCount++;
    if (this.ariaFailureCount >= this.threshold) {
      this.state = 'OPEN';
      console.error('> CRITICAL: Threshold Exceeded. Circuit Breaker TRIPPED.');
    }
  }

  private reset() {
    this.ariaFailureCount = 0;
    this.state = 'CLOSED';
  }
}

Open-Source Resiliency

We have packaged the core Stateful Circuit Breaker pattern into a zero-dependency TypeScript library ready for edge runtimes (e.g., Cloudflare Workers).

View the open-source code and implementation guidelines on GitHub:
👉 virtualsachin/agentic-circuit-breaker

The Verdict

Key Takeaway

Wrap Every LLM Provider in a Stateful Circuit Breaker.

Do not rely on a single frontier model provider. Wrap all LLM interactions in Circuit Breakers with Fallback Chains to guarantee sub-second resiliency during provider outages.