STEERPLANE
Runtime guardrails for autonomous AI agents. Observability tells you your agent failed. SteerPlane stops it before it does. Cost circuit-breakers, deterministic loop termination, and kill/alert enforcement that sit directly in the execution path. One line of code. Zero LLM-judge latency.
$ pip install steerplane$ npm install steerplaneAI agents are powerful. And dangerous.
Autonomous agents call APIs, run code, and make real-world decisions. Without guardrails, a single misconfigured agent can spin into an infinite loop, burn thousands of dollars in API credits overnight, or take a destructive action, and today's observability tools can only tell you about it after the fact. SteerPlane is built to intervene in real time, not just report.
Guardrails that actually stop the run
Every capability is production-ready and deterministic. Use the zero-code gateway, the SDK decorator, or native framework integrations, and get the same enforcement pipeline across all of them.
Loop Termination
A deterministic O(W²) sliding-window detector spots single-action, alternating, and multi-step repeating patterns in sub-millisecond time, then hard-terminates the run before it drains your budget on redundant calls. No LLM judge, no probabilistic guessing.
Cost Circuit-Breaker
Per-session USD ceilings across 25+ models with built-in pricing. On streaming responses, SteerPlane parses each chunk and severs the connection mid-stream the instant the ceiling is hit. Overshoot is bounded to a single step.
Deterministic Kill Mode
The moment a cost, step, or policy limit is breached, the run is terminated immediately, with no LLM judging another LLM, no probabilistic guessing. Loops and policy breaches always hard-terminate, as a non-overridable invariant. Human-in-the-loop alert mode (pause, notify, resume with extended limits) is available on the hosted/enterprise plan.
Policy Engine
A hierarchical deny → allow → rate-limit → approval pipeline with glob-pattern matching. Block destructive actions like delete_* and drop_*, rate-limit noisy calls, and gate sensitive operations like refund_* behind human approval, all before any LLM call is made.
Zero-Code Gateway
An OpenAI-compatible proxy that sits between your agent and the provider. Change only the base_url, and every call is monitored, policy-checked, and cost-tracked. Your real provider key stays server-side and never touches the agent process.
Framework-Agnostic
Drop-in integrations for LangChain, CrewAI, AutoGen, and the OpenAI Agents SDK, plus a Python decorator and TypeScript SDK. SteerPlane registers as the native callback/hook and routes every call through one guardrail pipeline, with your agent code unchanged.
Real-Time Dashboard
A live console that visualizes runs, execution timelines, cost breakdowns, and policy violations, with auto-refresh. Manage API keys and policies, and watch fleet-wide agent health at a glance.
Fault-Tolerant by Design
If the control plane goes offline, the SDK keeps enforcing loop detection, cost, and policy locally. Alert mode fails closed: the run terminates safely rather than continuing unprotected. No agent ever runs without at least one active enforcement path.
Open Source & Self-Hostable
MIT-licensed. Run the full stack (API, gateway, and dashboard) with one docker compose up. Kill-mode enforcement, loop detection, cost ceilings, and the policy engine are 100% free on the self-hosted stack, forever. The hosted/enterprise plan adds human-in-the-loop alert mode and managed infrastructure. The core guardrail engine is never gated.
Six steps. Under five minutes.
Install
pip install steerplane, or npm install steerplane. One dependency, zero config to start.
Wrap or Proxy
Add the @guard decorator, or point your OpenAI client's base_url at the SteerPlane gateway. No agent rewrite.
Set Limits
Declare cost ceilings, step limits, denied actions, rate limits, and approval gates, in code or a .steerplane.yml.
Agent Runs
Your agent executes normally. SteerPlane intercepts every LLM call and action in the path.
Guards Fire
Loops terminate, cost ceilings break the circuit, and policies block destructive actions, deterministically, in real time.
You See Everything
Every run, step, cost, and violation streams to the live dashboard for debugging and audit.
Two integration paths. Total protection.
Wrap a function with the decorator for deep control, or point your OpenAI client at the gateway for zero-code enforcement. Either way you get cost limits, loop detection, policy evaluation, and full telemetry out of the box.
# ── Option 1: Decorator (deep control) ──────────
from steerplane import guard
@guard(
agent_name="support_bot",
max_cost_usd=10.00,
max_steps=50,
denied_actions=["delete_*", "drop_*"],
)
def run_support_agent():
agent.run() # your code, unchanged
# Breach a limit -> hard-terminate, deterministically.
# ── Option 2: Gateway (zero code changes) ───────
import openai
client = openai.OpenAI(
base_url="http://localhost:8000/gateway/v1",
api_key="sk_sp_...", # your SteerPlane key
default_headers={"X-LLM-API-Key": "sk-..."}, # injected server-side
)
# Every call is now monitored, policy-checked, and cost-capped.A layered control plane
Agent calls are captured by the SDK or gateway, evaluated by the policy engine, loop detector, and cost tracker, then enforced by the kill/alert controller, with every decision persisted and streamed to the dashboard.
Built on proven foundations
Ready to secure your agents?
SteerPlane is open-source and free to start. Add one decorator or point your client at the gateway, and start stopping incidents in under five minutes.