The $1.6M Weekend

It started with a contract review agent. An MCP server wrapping a legal document API. Standard setup — LangGraph, GPT-4o, a handful of tools.

The agent hit an edge case on a Friday afternoon. A malformed API response triggered a retry loop. The framework's max_iterations was set to 50, but the agent was clever — it varied its queries just enough to avoid the cap while still hitting the same failing endpoint.

The numbers

By Monday morning:

• 4,847 API calls to the legal document provider (billed at $330/call for enterprise tier)
• 2.3M tokens consumed across GPT-4o
• $1.6M in combined API and compute costs
• One very uncomfortable board meeting

What went wrong

The framework did its job. It saved state. It managed the graph. It even logged the iterations.

What it didn't do:

1. Detect the loop — The agent varied its queries enough to stay under max_iterations, but a cost velocity check would have caught it in minutes
2. Track the side-effects — Every API call was billed. There was no mechanism to know which calls had financial consequences
3. Enforce a budget — There was no ceiling on total spend. The agent had an unlimited credit card
4. Alert anyone — The team found out Monday morning from an AWS billing alert, not from the agent framework

The fix

import { guard } from 'fuze-ai'

const reviewContract = guard(
  async (contractId: string) => {
    return await legalApi.review(contractId)
  },
  {
    maxCost: 50.00,      // $50 ceiling per call
    sideEffect: true,    // This costs money
    compensate: cancelReview,
  }
)

With Fuze, this incident would have been caught at multiple layers:

• Layer 2 (hash dedup): Similar queries flagged within the first 10 calls
• Layer 3 (cost velocity): $330/call rate flagged within 5 minutes
• Budget enforcement: $50 ceiling would have stopped the run early
• Daemon alerts: Team notified via webhook within minutes, not days

The broader problem

This isn't an isolated incident:

• $400M in collective Fortune 500 unbudgeted cloud spend from runaway agents in 2025
• $67.4B in global losses attributed to AI hallucinations
• 80% failure rate for multi-step agent workflows at 85% per-step accuracy

Every major framework — LangGraph, CrewAI, Google ADK — provides max_iterations and little else. State management is excellent. Failure management is nonexistent.

What we built

Fuze is the missing safety layer. It wraps your existing framework with:

• 5-layer loop detection that catches patterns max_iterations misses
• Budget enforcement that kills runs before they overspend
• Side-effect tracking that knows what's safe to retry
• EU AI Act compliance because enforcement is months away

One decorator. No framework migration. No infrastructure required.

npm install fuze-ai

Your agents are running. Make sure they're safe.