Clyro monitors and controls AI agents in real time.
System that catches runaway loops, caps the cost of every run and blocks actions that break your business rules, without changing how you build.
pip install clyro Try free for 10 agents, 100K traces/month. No credit card required.
Works with LangGraph, CrewAI, Claude Agent SDK, Anthropic SDK and any Python callable.
PROBLEM
Real incidents. Real costs. What happens without Clyro.
$47,000 burned. 11 days. Zero alerts.
An autonomous coding agent entered a loop and ran continuously for 11 days, generating $47,000 in API costs before anyone intervened.
Runtime controls like loop detection, cost bounds and step limits that Clyro brings to stop failures before they escalate.
One order. 260 McNuggets. No human in the loop.
An AI ordering agent added 260 McNuggets to a single customer order after incorrectly interpreting the request.
Runtime guardrails that Clyro uses to enforce business rules before agents take action in production.
Chatbot invents policy. Company loses lawsuit.
Air Canada's chatbot invented a discount policy that never existed. A customer relied on it while booking a flight. The airline refused to honor the discount, and a tribunal ruled the airline was responsible for the chatbot's mistake.
Context validation, freshness checks and runtime controls that Clyro adds to prevent unsupported responses.
Your agent cites information from 3 months ago. Confidently.
The agent always has the right information. Clyro keeps context fresh, validated and schema-enforced.
User A gets User B's context. Neither knows.
The agent remembers what matters. Clyro keeps memory isolated, versioned and accurate.
The agent books a flight, refunds a payment, deletes a file. High confidence. Wrong action.
The agent takes actions safely. Clyro enforces runtime guardrails before execution.
100 API calls become 10,000. The billing alert arrives too late.
The agent stays within execution limits. Clyro detects loops, caps costs and limits runaway runs.
Monday: 94% accuracy. Friday: 71%. Nobody noticed.
Every agent decision stays traceable. Clyro monitors execution paths, failures and drift in real time.
Prevention Stack
Four runtime controls built into every agent execution.
Observability tools tell you what failed after execution. Clyro's Prevention Stack is built to stop failures before they happen. Four runtime controls inside the Agent Kernel keep agent behavior predictable, bounded and traceable.
"They observe. We prevent."
FRAMEWORK
For developers connecting AI agents to tools via MCP. Compatible with LangGraph, CrewAI, Claude Agent SDK, Anthropic SDK and any MCP-compatible framework.
The Model Context Protocol connects AI agents directly to external systems. Without runtime controls, every tool call executes exactly as the model decides.
That's fine in a demo. It's a problem in production.
Clyro's Agent Kernel governs every MCP tool call with four built-in runtime controls:
Your rules, evaluated before every tool call
Define rules for any tool parameter using operators like max value, equals, and allowlists. Clyro can block violations instantly or log every decision for audit trails. Configure policies in YAML or manage them from the dashboard.
Append-only record of every tool call
Every tool call is logged with full execution context, including parameters, governance decisions, cost and outcomes. Clyro stores logs in append-only JSONL format with sensitive field redaction and fail-open execution handling.
Stops repeated tool call patterns
Detects when an agent makes identical tool calls in a loop (3 identical calls within a 10-call sliding window, SHA-256 signature matching). Stops the run before costs spiral.
Budget enforcement per session
Pre-call budget check before every tool execution. Default ceiling: $10 per session. Accumulated cost tracked across all tool calls with post-call reconciliation.
import clyro
# Wrap any agent - LangGraph, CrewAI, Claude Agent SDK, or your own
wrapped = clyro.wrap(your_agent, config=clyro.ClyroConfig(
agent_name="my-agent",
controls=clyro.ExecutionControls(
max_steps=50,
max_cost_usd=10.0,
enable_loop_detection=True,
enable_policy_enforcement=True,
),
))
result = wrapped.invoke(inputs)Five SDK adapters for instant integration:
LangGraph
callback handler with version validation
CrewAI
callback handler with version validation
Claude Agent SDK
instrumented agent handler
Anthropic SDK
traced client wrappers (sync + async)
Generic
works with any Python agent framework
The first runtime governance layer built for the MCP ecosystem.
CX USE CASE
For CX teams shipping AI into customer conversations.
Klarna deployed AI agents that handled 2.3 million customer conversations in a single month, equivalent to the workload of nearly 700 full-time support agents. The system handled volume well, but struggled with edge cases, policy decisions and conversations that required human judgment.
The real challenge starts when agents make decisions without enforcement boundaries. Without guardrails, AI agents invent refund policies, approve actions outside business rules and escalate problems only after customers notice them.
Clyro enforces business logic before agents take action:
Maximum refund amount: $500
The agent can't override this
Approved topics: returns, shipping, product info
The agent stays in its lane
Escalation triggers: legal questions, complaints, edge cases
The agent hands off to a human
Quantity limits: no single-item orders above 50 units
No more 260 McNuggets
You define the boundaries. The Prevention Stack enforces them. Your agents handle volume and know their limits.
# Clyro policy: cx-guardrails.yaml
# Pre-built CX templates available - customize or use the defaults
rules:
- id: refund-limit
name: "Maximum Refund Amount"
condition: { field: refund.amount, operator: max_value, value: 500 }
action: block
message: "Refunds over $500 require manager approval"
- id: topic-restriction
name: "Approved Response Topics"
condition: { field: response.topic, operator: in_list, value: [returns, shipping, product_info] }
action: allow
- id: quantity-cap
name: "Item Quantity Limit"
condition: { field: order.item_quantity, operator: max_value, value: 50 }
action: block
message: "Quantities over 50 require confirmation"
- id: escalation-trigger
name: "Human Escalation"
condition: { field: request.category, operator: in_list, value: [legal, complaint, edge_case] }
action: escalate
message: "Routing to human agent"Pre-built CX policy templates: refund limits, authority boundaries, quantity caps, escalation triggers. Customize or use the defaults.
Clyro enforces your business rules at runtime. One install, one line of code, and your agents run with built-in guardrails.
GET STARTED
Install the SDK, wrap your agent and get runtime governance immediately. Free tier, no credit card required.
pip install clyro
import clyro
clyro.configure(clyro.ClyroConfig(
api_key="cly_live_...", # Get yours at app.clyro.dev/signup
agent_name="my-first-agent",
))
# Wrap any framework: LangGraph, CrewAI, Claude Agent SDK, or your own
wrapped = clyro.wrap(your_agent)
result = wrapped.invoke(inputs)
# → Loop detection, cost bounds, step limits, and policy enforcement: active.PRICING
Start free. Scale when you're ready.
FREE
For individuals getting started with agent governance.
STARTER
For small teams collaborating on agent reliability.
TEAM
For teams running agents in production at scale.
ENTERPRISE
For organisations with compliance, SSO, and dedicated support needs.
Enterprise plan includes SSO, dedicated support, and custom data residency.