Cycles

Cycles

Runtime authority that blocks runaway agent spend and risky tool calls before they execute — self-hosted, Apache 2.0.

78/100Safe BetFree planFreemium

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

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
  • FinOps and platform leads who want hard pre-execution spend caps instead of post-hoc alerts
Not ideal for
  • 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
Visit Website

AdvancedLocal 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.Web · API · Plugin · Desktop · CLIAPI availableVerified 1h ago
Pricing
Free plan
FreemiumFree tier2 plans4 hidden costs
Learning curve
Advanced
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.
Runs on
WebAPIPluginDesktopCLI
API available · 15 integrations
Who it's for
Platform engineer at a tool-calling agent startupSaaS operator running multi-tenant agentsCompliance lead at a regulated firm
Live sentiment
Is Cycles actually worth it?

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
Run a free scan

3 free scans · no card needed

Skip it if

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.

The 30-second take
Biggest gripe

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.

Price reality

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 ago

Across the latest 4 updates: 4 changelog entries.

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

78/100
Safe Bet

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

Recent activity
90
Traction
100
Site health
95
User sentiment
25
What the vendor publishes
60

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

FreemiumAdvancedAPI availableWeb · API · Plugin · Desktop · CLI

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.

Platform engineer at a tool-calling agent startup

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.

SaaS operator running multi-tenant agents

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.

Compliance lead at a regulated firm

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

Models Under the Hood

GPT-5Claude

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.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — 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.

Annual total
Free
Over 12 months
Effective monthly
—
—

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.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • 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.
  • Paid Support is quoted as Custom, so budget for a procurement conversation rather than a self-serve checkout — and paid plans do not unlock features, only response targets, upgrade guidance, and incident support.
  • Audit-ready evidence retention and signed CyclesEvidence artifacts for regulated deployments sit inside paid support, so compliance-driven teams should price that tier before rollout.
  • Rolling over billing periods (RESET_SPENT) and force-releasing stuck reservations are operator tasks in the Admin API/dashboard — unglamorous maintenance work you own when you self-host.

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.

Migrating in
  • →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.
Migrating out
  • ↗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

OpenAIAnthropicAWS BedrockGoogle GeminiGroqOllamaLangChainLangGraphVercel AI SDKSpring AILlamaIndexCrewAIPydantic AIAutoGenOpenAI Agents

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.

Featured Head-to-Head Comparisons

Popular in AI Governance & Guardrails

Mindgard

Mindgard

Mindgard automates AI red teaming — agent-native reconnaissance, exploit validation, and continuous AI security testing for production AI

Contact SalesTry
Poolside 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

Contact SalesTry
Olas Network

Olas Network

Co-own autonomous AI agents on-chain: stake OLAS, run agents that trade, hire each other and settle payments.

FreeTry

Frequently Asked Questions

Used Cycles? Help shape our editorial sentiment research.