AIToday

SHACKLE: fail-closed governance standard for autonomous AI agents

Hacker News6h ago
SHACKLE: fail-closed governance standard for autonomous AI agents

Key takeaway

Dante Bullock released SHACKLE, a runtime governance standard for autonomous AI agents that stops runaway token loops and budget overruns by mediating every tool call against a verifiable conformance spec (SP/1.0). The system uses a deterministic decision model (ALLOW / DENY / HITL) defined in 15 hash-verifiable fixtures that any agent framework can test against for public certification, solving a systemic failure where agents enter infinite retry loops when tools fail—burning API budgets in minutes.

Summaries like this, in your inbox every morning.

Sign up free →

3 Key Points

  • What happened

    Dante Bullock released SHACKLE, a runtime governance layer and SP/1.0 conformance standard for autonomous AI agents. The system mediates every agent tool call in real time, stopping runaway token loops, unhandled tool cascades, and budget overruns before they execute. It ships as 15 hash-verifiable conformance vectors, a stdlib-only reference implementation, and integrations for LiteLLM and AutoGen, published June 17, 2026.

  • Why it matters

    AI agents today lack native spending guardrails and loop breakers, causing them to retry identical failed tool calls—burning context and incurring massive API bills in minutes (the "Loop of Death"). SHACKLE's conformance model (Valid(τ) ⇔ Required(τ) ⊆ Supported(τ)) defines a verifiable decision surface (ALLOW / DENY / HITL) that any runtime can test against public fixtures, giving buyers and regulators reproducible proof that an autonomous system does what it is allowed to do—and nothing else.

  • What to watch

    SHACKLE Certification has three levels (SP/1.0-Core, SP/1.0-HITL, SP/1.0-Sovereign), measured against public fixtures in a registry open to any agent runtime. The system intercepts LLM calls and tool execution client-side, with no telemetry or phone-home—available now from source or PyPI as pyshackle.

In Depth

Dante Bullock, a 52-year-old self-taught systems architect from Oakland, California, built SHACKLE out of necessity. He audited issue trackers in CrewAI, AutoGen, and LangGraph to map the exact systemic failures affecting developers in production—real-time web scraping and community sentiment mining identified the root cause: agents without native circuit breakers or spending controls. The result is SHACKLE, published June 17, 2026, shipped with no venture capital and no corporate incubator.

SHACKLE operates as a lightweight governance layer that sits inside your runtime via dynamic Python shims. It intercepts LLM calls and tool execution client-side, monitoring execution state deterministically. The core invariant is that cost is read from usage after each call, so SHACKLE halts the loop, not the single call that crossed the line. When an agent breaches your boundaries—identical sequential tool calls, error cascades, budget overrun, or execution timeout—SHACKLE trips the circuit breaker and drops you into an interactive terminal console with Resume / Skip / Abort options.

The system ships as SP/1.0 (SHACKLE Protocol 1.0), a conformance standard with three layers of certification. SP/1.0-Core verifies that every mediated action resolves to the correct ALLOW / DENY / HITL verdict with the correct deny reason. SP/1.0-HITL adds proof that rejected and deferred actions cannot execute by being replayed, covering all five human-in-the-loop transitions: approve, reject, modify, defer-escalate, and duplicate-resume. SP/1.0-Sovereign adds atomic daemon state, tamper-evident ledgering, and audit export for enterprise accountability. Certification is measured entirely against 15 hash-verifiable fixtures (fixtures/conformance.json)—10 decision-core cases plus 5 HITL transition cases—and a stdlib-only reference implementation (shackle/conformance.py). The same vectors that certify a runtime are the ones anyone else can re-run to check the claim; there is no private audit or pay-to-pass seal. Verified runtimes appear in the public SHACKLE Conformance Registry with the level achieved, SP/1.0 version, and date.

Integrations ship first-class: a LiteLLM guardrail (shackle/litellm_shackle_guardrail.py) enforces SP/1.0 on any LiteLLM-powered agent (CrewAI, AutoGen, LangGraph, custom), and an AutoGen wrapper (shackle/autogen_shackle_wrapper.py) wraps tool calls through the same engine. Because LiteLLM sits under most agent frameworks, the guardrail governs them through a single chokepoint. Installation is one line: pip install -e . from source or pip install pyshackle from PyPI. Guarding a workflow requires one decorator: @Guard(budget=0.25, max_repeat_calls=3, timeout_seconds=180). SHACKLE is purpose-built for local development, debugging, CLI agents, cross-framework coverage, and budget enforcement during iterative testing; for headless production APIs where blocking for human input is not an option, Bullock recommends considering framework-native solutions like TokenCircuit for automated LangGraph overrides.

Context & Analysis

AI agents have matured in capability but remain brittle in error handling. Frameworks like CrewAI, AutoGen, and LangGraph lack native, framework-agnostic spending guardrails or deterministic loop breakers. The result is a systemic failure mode: when an agent hits an unhandled tool error, it does not self-correct but instead enters a retry spiral, exhausting context and incurring runaway API costs. Bullock's response was to build SHACKLE not as a proposal but as a working standard—a conformance spec backed by executable tests and a reference implementation that can be independently verified.

The core insight of SP/1.0 is that a runtime's conformance cannot be asserted; it must be proven. The standard defines three things: a decision surface with three and only three verdicts (ALLOW / DENY / HITL), a conformance model grounded in set theory (Valid(τ) ⇔ Required(τ) ⊆ Supported(τ)), and a critical invariant that history-visible does not equal runtime-executable—meaning a rejected or deferred action that re-enters the loop is denied again, not waved through on replay. These principles close a class of failures where agents "resume" past their own guardrails. Because the fixtures are public, the reference implementation is stdlib-only, and the certification process is open to any framework, SHACKLE functions as a neutral arbiter: buyers and regulators can verify in minutes, from a clean clone, that an autonomous system does what it claims.

FAQ

What problem does SHACKLE solve?
When an AI agent encounters an unhandled tool error (like a 401 Unauthorized or changed API payload), it typically retries the exact same tool with the same input instead of self-correcting, entering a "Loop of Death" that burns context windows and runs up massive API bills in minutes. SHACKLE detects identical sequential tool calls and error cascades, halting execution before the next call fires.
How do I verify that a runtime is SHACKLE-conformant?
SHACKLE publishes 15 hash-verifiable conformance vectors in fixtures/conformance.json and a stdlib-only reference implementation in shackle/conformance.py. Any runtime can run pytest tests/test_conformance.py against the public fixtures; if it passes, it appears in the public SHACKLE Conformance Registry at the appropriate level (SP/1.0-Core, SP/1.0-HITL, or SP/1.0-Sovereign), verified reproducibly by anyone.
What are the three decision verdicts SHACKLE enforces?
SHACKLE resolves every mediated action to exactly one of three verdicts: ALLOW (permit the action), DENY (block it with a deterministic reason), or HITL (halt for human approval, rejection, modification, deferral-escalation, or resumption of a duplicate).

Get the latest Large Language Models news every morning

AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.

Free · takes 30 seconds · unsubscribe anytime

Discussion

No comments yet. Be the first to share your thoughts!

Log in to join the discussion

Related Articles

Stay ahead with AI news

Get curated AI news from 200+ sources delivered daily to your inbox. Free to use.

Get Started Free

Free · takes 30 seconds · unsubscribe anytime

1 minute a day. The AI essentials.

200+ sources · Email / LINE / Slack

Get it free →