Cycles
Runtime authority that blocks runaway agent spend and risky tool calls before they execute — self-hosted, Apache 2.0.
Most guardrail tools watch; Cycles denies. If your riskiest action is an agent tool call that never touches an LLM, a provider spend cap and a rate limiter both miss it — Cycles rejects it pre-dispatch and leaves a verifiable record. The honest tradeoff: you self-host the server, events service and dashboard, Redis is mandatory, and the managed cloud on runcycles.ai is planned but not yet available. Worth the ops overhead once agent spend is a real line item.
Verified 1h ago · liveness 78/100 · cite: rightaichoice.com/tools/cycles
- Engineering teams running tool-calling agents in production or shipping them within weeks
- Platform teams comfortable self-hosting Docker, Redis and PostgreSQL
- SaaS platforms that need per-tenant budget isolation so one customer's loop can't drain a shared pool
- FinOps and platform leads who want hard pre-execution spend caps instead of post-hoc alerts
- Simple chatbots with no tool calls and no meaningful spend exposure
- Teams whose only needs are token counting, tracing or per-minute rate limiting
- Shops without anyone to run Docker, Redis and PostgreSQL
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Cycles if you only need tracing or post-hoc cost dashboards, if your agents make no tool calls, or if nobody on your team can operate Docker, Redis, and PostgreSQL in production.
Self-hosting is free under Apache 2.0, but you pay in infra and on-call time: the runtime server, events service, and dashboard all need Redis, PostgreSQL, and monitoring.
The Apache 2.0 self-hosted tier is $0/mo with no license key, no seat fees, and no percentage of model or agent spend — cheaper than gateways that bill a cut of every call, and cheaper than per-seat observability platforms once you have many agents. Paid Support is Custom and flat, independent of tokens, requests, agents, and tenants. That places Cycles below managed LLM-gateway pricing but above a straight LiteLLM or Helicone deployment on operational effort, since you supply the Redis and
In short
Cycles — Runtime authority that blocks runaway agent spend and risky tool calls before they execute — self-hosted, Apache 2.0. Best for Engineering teams running tool-calling agents in production or shipping them within weeks, Platform teams comfortable self-hosting Docker, Redis and PostgreSQL, SaaS platforms that need per-tenant budget isolation so one customer's loop can't drain a shared pool. Free to use.
What's new in Cycles
Checked 5 days agoAcross the latest 4 updates: 4 changelog entries.
TypeScript client 0.4.3
TypeScript SDK updated to 0.4.3 with Node 20+ native fetch support. Post-action failures no longer release known spend, and invalid actuals settle the marked estimate.
Protocol spec v0.1.25.16 and cycles-server v0.1.25.59
Protocol spec revision and runtime server patch released with additive-only changes, keeping the wire format stable within 0.1.x.
Governance spec, admin, and dashboard updates
Governance spec v0.1.25.42, cycles-server-admin v0.1.25.55, and cycles-dashboard v0.1.25.85 shipped with ongoing refinement.
cycles-server-events v0.1.25.25
Events service patch release forming part of the patch stream after the initial v0.1.25 Events & Webhooks launch.
What people actually say about Cycles — is it worth it?
We scanned public community sources for Cycles on Jul 4, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Cycles? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Reserve-Commit-Deny lifecycle that rejects agent actions before they execute
- Returns 409 BUDGET_EXCEEDED so the host skips the downstream call
- Per-action cost caps with TTL, grace period and extend support
- Tool-exposure risk budgets with caller-assigned RISK_POINTS scored before dispatch
- Shadow mode / dry run that enforces policies against live traffic without blocking
- Decide preflight checks for action governance before dispatch
- Multi-tenant budget scoping across tenant, workflow and run levels
- Shared budget pools with tenant-close cascade prevention
- CyclesEvidence verifiable record of reservations, denials and settlements
- Webhook event delivery with scope filter syntax
- Prometheus metrics and dashboard monitoring for runtime authority
- Python @cycles decorator, TypeScript withCycles wrapper, Spring and Rust clients
- MCP server for Claude Desktop, Claude Code, Cursor and Windsurf
- Cycles Budget Guard for Claude Code
- Blast radius risk calculator and Claude vs GPT cost calculator, shareable and embeddable
About Cycles
Cycles is a self-hosted runtime authority for autonomous agents: it reserves budget and checks action exposure before an LLM call or tool dispatch actually fires. The core mechanic is a Reserve-Commit-Deny lifecycle — every action requests a reservation, gets approved or rejected, and only runs if the reservation lands. That ordering is the whole point. Dashboards, token counters and rate limiters tell you what you already spent; Cycles returns 409 BUDGET_EXCEEDED and the host skips the call. The vendor's demos make the difference concrete. A runaway agent is stopped at a $1 cap in roughly 30 seconds (~$5.95 modeled locally; ~$10 in 12s in the accelerated recording). In a tool-exposure scenario, four mocked customer actions execute without Cycles, but the outbound email is skipped once its reservation is rejected. In an illustrative coding-agent loop, a mandatory $15 run budget rejects a protected call around iteration 68 of 240 — $52.80 in modeled spend. Budgets scope across tenants, workflows and runs, with shared pools and tenant-close cascade semantics for SaaS operators who can't let one customer's retry loop drain an allocation everyone shares. Per-action caps carry TTL, grace period and extend support; overage policies, debt and overdraft are configurable; tenant, budget and API key management run through an Admin API. A Decide preflight call, webhook event delivery with scope filtering, Prometheus metrics, Shadow mode for dry-running policies against live traffic, and CyclesEvidence — a verifiable record of each pre-execution decision, denial and settlement — round out the governance surface. SDKs cover Python, TypeScript, Java/Spring and Rust, plus an MCP server for Claude Desktop, Claude Code, Cursor and Windsurf. Deployment is Docker-based with Redis required, and the docs claim the full stack in under five minutes. It is not an LLM gateway and not an observability tool, and the vendor publishes explicit comparison pages against rate limiting,
Behind the Verdict
The question that decides Cycles for you is simple: do you need the denial to happen before the call, or is after-the-fact visibility enough? If a post-hoc spend alert fits your risk model, Helicone or LangSmith will do the job for less operational work. If one runaway retry loop can burn a budget you'd have to explain to a customer or a CFO, the Reserve-Commit-Deny ordering is what you're buying. We'd reach for this when agents already make tool calls in production or are days away from it. The one-decorator path is genuinely small — an @cycles decorator in Python or a withCycles wrapper in TypeScript on a single function, then wrap a tool call with a tool-exposure estimate and require a reservation before dispatch. From there the rollout ladder (local demo, one LLM call, one tool call, Shadow mode, hard enforcement) is the part worth copying. Shadow mode against live traffic is how you calibrate budgets without blocking anyone on day one, and it's the step most teams skip. Where it bites is multi-tenancy. Shared budget pools and tenant-close cascade semantics exist precisely because one tenant's loop can exhaust an allocation everyone draws on, and that's a design problem you have to configure, not a checkbox. Get scope derivation wrong and you'll be debugging which budget actually governed a call rather than why it was denied. The docs flag scope misconfiguration as a named incident pattern for a reason. Be precise about what ships today. Tool-exposure limits run on risk budgets your application assigns; server-enforced action-kind quotas and action-kind allow/deny policies are labeled preview features. If your requirement is server-side policy over action kinds, you're early. Against LiteLLM or a provider spend cap, Cycles is the better answer when the
Researching Cycles? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Cycles actually fits — and what changes day-one when you adopt it.
Deploys the full stack with Docker, wraps one Python LLM call in the @cycles decorator with a 5,000-unit estimate, then assigns a tool-exposure estimate to the outbound-email tool and requires a reservation before dispatch.
Outcome: The first runaway loop is rejected with 409 BUDGET_EXCEEDED before the downstream call, and the customer email is skipped rather than sent.
Configures separate tenant budgets plus a shared provider pool, then relies on tenant-close cascade semantics so one research loop cannot consume the allocation every other tenant depends on.
Outcome: Per-tenant isolation bounds each customer's submitted usage on instrumented paths instead of letting one loop interrupt everyone.
Enables CyclesEvidence envelopes and webhook event delivery with a scope filter, then correlates reservation lifecycle records with application logs for tool authorization and outcomes.
Outcome: Each pre-execution decision, denial, and commit is recorded in a verifiable trail rather than reconstructed after the fact.
Use Cases
- Set hard cost caps per agent run so a runaway loop is rejected before the next call, not flagged after the invoice
- Block risky tool calls (customer email, deploy, mutations) by requiring a reservation before dispatch
- Isolate per-tenant AI budgets in a multi-tenant SaaS so one customer's retry loop can't drain a shared allocation
- Produce verifiable pre-execution decision records via CyclesEvidence for audit and compliance reviews
- Dry-run budget and risk policies in shadow mode against real traffic before flipping to hard enforcement
- Bound concurrent overspend and retry storms with shared pools and per-action caps carrying TTL and grace periods
- Give coding agents in Claude Code, Cursor, or Windsurf a budget guard through the MCP server
Models Under the Hood
as of 2026-10-17
Limitations
- Cycles is self-hosted runtime authority infrastructure — you deploy and operate the server, events service, and dashboard yourself, and Redis is required.
- The project is still on 0.1.x (protocol spec v0.1.25.16 and cycles-server v0.1.25.59 as of 2026-07-28), and the vendor states wire format is additive-only within 0.1.x.
- Tool exposure limits today use risk budgets configured by your application; server-enforced action-kind quotas and action-kind allow/deny policies are labeled preview features.
- Cycles issues the budget decision, but your application still controls tool permissions and must enforce the result.
- It is not an LLM gateway, not an observability platform, and not a content-moderation filter.
as of 2026-10-03
Verification history
We have re-verified Cycles 11 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 11 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Cycles tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source (self-hosted)
$0
Ideal for
Engineering and platform teams with Docker and Redis capability that want budget and tool-exposure enforcement without any spend-based fee.
What this tier adds
Starting tier and free entry point: Apache 2.0 software, no license key, no seat fees, no percentage of agent or model spend, with all SDKs, the MCP server, shadow mode, and CyclesEvidence.
Paid Support
Custom
Ideal for
Teams running Cycles as a production control point, and regulated or enterprise deployments that need audit-ready evidence handling.
What this tier adds
Adds response targets, upgrade guidance across protocol and server releases, incident support, architecture review of your rollout and budget design, plus optional evidence retention and signed artifacts.
Where the pricing makes sense
The company stage and team size where Cycles's pricing actually pencils out — and where peers do it cheaper.
The Apache 2.0 self-hosted tier is $0/mo with no license key, no seat fees, and no percentage of model or agent spend — cheaper than gateways that bill a cut of every call, and cheaper than per-seat observability platforms once you have many agents. Paid Support is Custom and flat, independent of tokens, requests, agents, and tenants. That places Cycles below managed LLM-gateway pricing but above a straight LiteLLM or Helicone deployment on operational effort, since you supply the Redis and
Setup time & first value
How long it actually takes to get something useful out of Cycles — broken out by persona, not the marketing-page minute.
Local demo: about 5 minutes with one script and no API keys, watching a runaway agent stop at the $1 cap. Wrapping one LLM call: roughly 10 minutes with a single @cycles decorator or withCycles wrapper. Adding a guarded tool call: about 30 minutes. Shadow mode calibration: a day or more against real traffic. Hard enforcement: flip one workflow to live once budgets look right.
Switching to or from Cycles
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From a custom rate limiter: the docs include a dedicated 'Migrate from Custom Rate Limiter' guide alongside an 'Adding Cycles to an Existing App' path.
- →From LiteLLM or another gateway: keep the gateway for provider routing and add Cycles for pre-execution budget and tool-exposure decisions on instrumented operations.
- →From LangChain-only agents: follow the Budget Control for LangChain Agents guide and the LangChain.py / LangChain.js integration pages.
- →From Spring AI: use the Spring Boot @Cycles annotation and Spring AI Starter configuration plus the Budget Limits with Spring AI guide.
- ↗To LangSmith or Helicone: keep them for tracing and post-hoc cost analytics if you decide you only need observability, not pre-execution enforcement.
- ↗To provider-side spend caps: rely on vendor budget limits at the model boundary, accepting that tool calls which never touch an LLM stay ungoverned.
- ↗To Guardrails AI: move to input/output validation and moderation if your risk is content rather than spend and action exposure.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Cycles”, and we withheld 6: 6 could not be judged, because “Cycles” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Cycles.
Official links
Featured Head-to-Head Comparisons
Cycles vs Spider Cloud
Don't compare apples to oranges. If you need to stop runaway agent spend and enforce tenant-level budgets before any action executes, choose Cycles. If you need to feed your AI agent fresh web data at low cost with structured output, choose Spider Cloud. They solve different problems and can even complement each other.
Cycles vs Temporal Ai
Choose Cycles if your primary concern is preventing runaway AI agent spend and enforcing granular cost/risk policies pre-execution, especially in multi-tenant SaaS settings. Choose Temporal if you need rock-solid durable execution for multi-step workflows that must survive crashes and retries, with a mature open-source ecosystem and cloud option.
Cycles vs Presto Voice
If you're building and deploying autonomous AI agents in production, Cycles provides the pre-execution budget control and blast radius isolation that post-hoc monitoring tools lack. Presto Voice is a specialized drive-thru voice AI solution that increases revenue and efficiency for QSR chains. These tools serve completely different markets — choose based on whether you need agent cost governance or restaurant automation.
Popular in AI Governance & Guardrails
Mindgard
Mindgard automates AI red teaming — agent-native reconnaissance, exploit validation, and continuous AI security testing for production AI
Poolside AI
Poolside builds open-weight agentic coding models — Laguna XS 2.1 (33B) and Laguna S 2.1 (118B) — for code that stays inside your security
Olas Network
Co-own autonomous AI agents on-chain: stake OLAS, run agents that trade, hire each other and settle payments.
Frequently Asked Questions
Categories
Topics
Used Cycles? Help shape our editorial sentiment research.