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.
Kill / Alert Enforcement
Not a binary kill-or-nothing switch. Kill mode terminates instantly on violation; alert mode pauses, notifies, and waits for human approval — then resumes with extended limits. Loops and policy breaches always hard-terminate, as a non-overridable invariant.
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 — 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 — 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, policy violations, and pending approvals — 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 — and alert mode automatically degrades to kill mode. No agent ever runs without at least one active enforcement path.
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, policies block destructive actions, and alert-mode pauses for approval — 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_*"],
enforcement="alert", # pause + ask a human near the limit
)
def run_support_agent():
agent.run() # your code, unchanged
# ── 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.