⚠ Production Warning

YOUR AGENT
IS BLEEDING
MONEY.
RIGHT NOW.

$106,000 Reported Loss — AutoGen #7770 AutoGen #7770 — Agent destroyed AWS management account

SHACKLE is the 1-line runtime circuit breaker that stops autonomous agents from burning your API budget in silent infinite loops. Works with CrewAI, LangGraph, AutoGen — zero refactoring.

See How It Works ↓ View Source (AGPLv3) Pricing & Implementation ↓
$ python agent_kickoff.py
[Agent] Running research task...
[Tool] web_search("latest AI news") → 200 OK
[Tool] web_search("latest AI news") → 401 Unauthorized
[Tool] web_search("latest AI news") → 401 Unauthorized ⚠

⛓️ SHACKLE CIRCUIT BREAKER: REPETITIVE_TOOL_CALL

Agent: ResearchAgent
Tool: web_search
Input: {"query": "latest AI news", "error": "401 Unauthorized"}
Call Count: 3x → CIRCUIT OPEN

━━━ Session Stats ━━━
Tokens: In: 8,400 | Out: 1,200
Session Cost: $0.02850 (saved: ~$400.00)
Time Running: 47.2s

[R] Resume/Reset  [S] Skip  [A] Abort
▌
// The Crisis

Your Agent Is Bleeding Money. Right Now.

🔄 The Loop of Death

Agent hits an error. Retries same tool with same input. Burns tokens quadratically. You wake up to a $400 bill — or worse, a $106,000 AWS disaster — with no idea what happened.

💰 No Native Budget Enforcement

CrewAI, AutoGen, and LangGraph have zero built-in cost guardrails. Your agent runs until it runs out of your money. Framework developers admit this is unsolved.

⏱️ Hung Tools, Silent Failures

API hangs. Agent waits forever. No timeout. No alert. Just a frozen process burning compute budget. Across 20+ agents in production, this compounds exponentially.

📊 Cross-Framework Invisible

Production stacks run CrewAI + AutoGen + LangGraph simultaneously. Each framework has different failure modes. None has a unified circuit breaker. Until now.

// Case Study

This Actually Happened.

$106,000

An AutoGen agent managing 10,000+ AWS accounts destroyed the management account in a recursive cleanup loop. No circuit breaker. No budget guard. No kill switch.

Source: microsoft/autogen#7770 — @tzb1-ai, enterprise infrastructure operator

SHACKLE's repeat-call + error-cascade breaker is built to trip on exactly this recursive-loop pattern—before it compounds.

// Solution

One Decorator. Zero Refactoring.

$ cat agent.py

from shackle import Guard

@Guard(budget=0.25, max_repeat_calls=3, timeout_seconds=180)
def safe_kickoff():
    return crew.kickoff()

safe_kickoff()

$ pip install shackle-guard && python agent.py
✅ SHACKLE active. Guards: budget=$0.25, repeat=3x, timeout=180s

SHACKLE hooks litellm.completion and BaseTool.run at the interpreter level. No framework source changes. No refactoring. Works across CrewAI, LangGraph, and AutoGen simultaneously.

🛑

Loop of Death Prevention

Detects identical sequential tool calls and error cascades. Trips circuit breaker before quadratic token burn.

💰

Budget Enforcement

Real-time token tracking against client-side pricing table. Hard freeze when budget is exhausted.

⏱️

Execution Timeouts

Kills hung threads on dead APIs. No more frozen processes burning compute.

🖥️

HITL Console

Interactive terminal with Resume / Skip / Abort. Human stays in the loop when it matters.

🔒

100% Client-Side

No telemetry. No phone-home. No hidden SaaS. Your agent data stays on your machine.

🔀

Cross-Framework

CrewAI ✅ LangGraph ✅ AutoGen ✅ Smolagents 🧪 — one decorator, all frameworks.

// Why SHACKLE Exists

Nothing Else Does This.

Every AI agent framework offers some safety mechanism — but none provide a dedicated pre-execution circuit breaker with mathematically verified decision logic. Here's the landscape:

Capability Prompt Guards Framework Limits LangSmith / Monitoring SHACKLE
Pre-execution interception ✗ In-band ✗ Post-hoc ✗ Observability only ✓ Process-level
Budget enforcement ✗ △ Token count only ✗ ✓ Per-session USD tracking
Loop-of-death detection ✗ △ Recursion limit △ After-the-fact ✓ 3-call repeat + error amplification
HITL (human-in-the-loop) ✗ △ Manual only ✗ ✓ CLI + WebSocket remote
Error signal detection ✗ ✗ ✗ ✓ 401/403/500/timeout cascade
Mathematical verification ✗ ✗ ✗ ✓ 9 invariants (Hypothesis-tested)
Cryptographic audit trail ✗ ✗ ✗ ✓ Ed25519-signed, immutable
Framework-agnostic ✗ ✗ Framework-locked △ LangChain only ✓ Works with ANY agent
Zero-refactor integration △ System prompt ✗ Requires config ✗ Requires SDK ✓ One decorator: @Guard
Open source △ Varies ✓ ✗ Proprietary SaaS ✓ AGPLv3 + commercial

The gap: Every framework has prompt guards, rate limits, and monitoring. Nobody has a pre-execution circuit breaker with mathematically verified decision logic. That's what SHACKLE is. One import. Zero refactoring. Works today.

// Architecture

Interpreter-Level Interception.

SHACKLE sits between your agent and the runtime — not as middleware, but as a runtime shim.

┌─────────────────────────────────────────────────────────┐ │ SHACKLE RUNTIME ENVELOPE │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ CrewAI │ │ AutoGen │ │LangGraph │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ │ └───────────────┬───────────────┘ │ │ │ │ │ ┌────────▼────────┐ │ │ │ SHACKLE GUARD │ ← litellm hook │ │ │ decide(state, │ ← BaseTool.run hook │ │ │ call) → Verdict│ ← Agent.execute_task │ │ └────────┬────────┘ │ │ │ │ │ ┌────────────┼────────────┐ │ │ │ │ │ │ │ ┌────▼───┐ ┌─────▼────┐ ┌────▼─────┐ │ │ │ ALLOW │ │ DENY │ │ HITL │ │ │ │ execute│ │ block + │ │ pause + │ │ │ │ tool │ │ log │ │ console │ │ │ └────────┘ └──────────┘ └──────────┘ │ │ │ │ V1 (Local): In-process, memory state, CLI HITL │ │ V2 (Sovereign): Sidecar daemon, Redis, Postgres, WSS │ └─────────────────────────────────────────────────────────┘
// Deployment

Two Paradigms. One Protocol.

🖥️ LOCAL HITL (V1)

  • In-process decorator — zero infrastructure
  • Terminal-based HITL console
  • Memory-only state (lost on crash)
  • Perfect for development & debugging
  • pip install shackle-guard
  • Free — AGPLv3
View on GitHub →

🏰 ENTERPRISE SOVEREIGN (V2)

  • Sidecar daemon — persistent state
  • Web/mobile remote HITL console
  • Redis + Postgres — state survives crashes
  • Distributed budget across serverless/K8s
  • SOC2 audit logs (cryptographically signed)
  • Commercial license available
Contact for Pricing →
// Testimonials

What Developers Say.

"SHACKLE's litellm hook is brilliant for teams running polyglot stacks (CrewAI + AutoGen + LangGraph). You get one unified guardrail across your whole topology."

— Creator of TokenCircuit, competing LangGraph solution

"The error-amplification logic (catching 401/500s on the 2nd attempt) is incredibly sharp."

— Developer on LangGraph issue tracker

🔗 Seeking Integration Partners

Running multi-agent production systems? SHACKLE fills the circuit breaker gap in your delegation protocol. We're looking for integration partners with live production deployments. Cross-framework, sandbox-compatible, runtime-level.

Propose Integration →
// Pricing

Stop the Bleeding. Today.

Open Source

$0
  • Full V1 decorator source
  • Terminal HITL console
  • Budget + repeat + timeout guards
  • AGPLv3 license
  • Community support
  • Distributed state
  • SOC2 audit logs
  • Commercial license
GitHub →

Implementation + Audit

$2,500
  • Architecture audit of your agent topology
  • Custom SHACKLE configuration
  • Integration with your codebase
  • Direct engineer access (not support tickets)
  • 30-day guarantee — catches a loop or it's free
  • Same-day response (within 4 hours)
Book Implementation →

Enterprise Sovereign

Custom
  • V2 sidecar daemon + distributed state
  • Postgres audit logs (SOC2-ready)
  • Remote HITL console (web/mobile)
  • Multi-tenant isolation
  • Commercial license (no copyleft)
  • SLA-backed priority support
  • On-premise deployment
Contact →
// Provenance

Built by Someone Who Ships.

Dante Bullock — 52-year-old self-taught systems architect, Oakland, California. Founder of Sovereign Logic. No venture capital. No corporate incubator. Just code that works.

"I don't wait for VC validation. I scrape issue trackers, find the bleeding, and build the tourniquet."

GitHub: @Fame510  |  docspoc101@gmail.com