Skip to content

Main Navigation Why Cycles Quickstart

Getting Started

Reference

API Reference (Interactive)

Admin API (Interactive)

Operations

Incident Patterns

Appearance

Sidebar Navigation

Why Cycles

Cost Control

Action Authority

Multi-Tenant Isolation

Quickstart

What is Cycles?

End-to-End Tutorial

Add to a Python App

Add to a TypeScript App

Add to a Spring Boot App

Add to a Rust App

Add to Claude / Cursor / Windsurf

Budget Limits with Spring AI

Choose a First Rollout

Architecture Overview

Deploy the Full Stack

Self-Hosting the Server

Deploy the Events Service

Concepts

Why Rate Limits Are Not Enough

What Cycles Is Not

Idempotency, Retries and Concurrency

From Observability to Enforcement

Coding Agents Need Runtime Authority

Exposure

Action Authority

Why Agents Do Not Replace Cycles

Comparisons

Overview

How Cycles Compares

vs Rate Limiting

vs LangSmith

vs Guardrails AI

vs Provider Caps

vs Token Counters

Webhooks and Events

Glossary

How-To Guides

Adding Cycles to an Existing App

Choosing the Right Pattern

Budget Patterns

Choosing the Right Overage Policy

Multi-Tenant SaaS Guide

Common Budget Patterns

Multi-Agent Shared Budgets

Cost Estimation Cheat Sheet

Budget Allocation and Management

Tenant, Workflow, and Run Budgets

Estimate Exposure Before Execution

Degradation Paths

Budget Control for LangChain Agents

Shadow Mode Rollout

Tenants and Configuration

Tenants, Scopes, and Budgets

Tenant Management

API Key Management

Custom Field Resolvers

Programmatic Client Usage

Error Handling

Error Handling Patterns

Error Handling in Python

Error Handling in TypeScript

Handling Streaming Responses

Testing with Cycles

Troubleshooting and FAQ

Integrations

Ecosystem

Overview

LLM Providers

OpenAI (Python)

OpenAI (TypeScript)

Anthropic (Python)

Anthropic (TypeScript)

AWS Bedrock

Google Gemini

Groq

Ollama / Local LLMs

AI Frameworks

LangChain.py

LangChain.js

LangGraph

Vercel AI SDK

Spring AI

LlamaIndex

CrewAI

Pydantic AI

AnyAgent

AutoGen

Agent Platforms

MCP (Claude, Cursor, Windsurf)

OpenAI Agents

OpenClaw

Web Frameworks

Next.js

Express

Django

Flask

FastAPI

Protocol Reference

API Reference (Manual)

API Reference (Interactive)

Reserve / Commit Lifecycle

Authentication and Tenancy

Scope Derivation

Understanding Units

Caps and Three-Way Decisions

Commit Overage Policies

TTL, Grace Period, and Extend

Decide: Preflight Checks

Dry Run and Shadow Mode

Events and Direct Debit

Debt and Overdraft

Querying Balances

Reservation Recovery and Listing

Metrics and Metadata

Error Codes and Error Handling

Webhook Event Delivery Protocol

Configuration Reference

Python Client Configuration

TypeScript Client Configuration

Spring Client Configuration

Server Configuration

SpEL Expression Reference

Incident Patterns

Runaway Agents and Tool Loops

Retry Storms

Concurrent Agent Overspend

Scope Misconfiguration

Operations

Security

Production Operations

Admin API Guide

Client Performance Tuning

Observability Setup

Monitoring and Alerting

Security Hardening

Managing Webhooks

Webhook Integrations

Changelog

Community

Built with Cycles Badges

On this page

Community

Resources for projects built with Cycles.

Built with Cycles Badges — add a badge to your project's README

Edit this page on GitHub

Last updated:

Pager

Was this page helpful?

Released under the Apache 2.0 License.

Copyright 2025-present RunCycles.io