26 Integrations: Every AI Framework, One Budget Protocol

When we launched Cycles, the question we heard most was: "Does this work with my stack?"

Today the answer is yes — for almost every stack. Cycles now integrates with 26 frameworks across Python, TypeScript, and Java. Every LLM call, tool invocation, and agent action in your stack can be governed with the same reserve → commit → release protocol — enforcing spend limits, action boundaries, and risk controls before execution.

What shipped

We added 9 new integration guides, bringing the total from 17 to 26:

LLM Providers (8)

Provider	Languages	What's new
OpenAI	Python, TypeScript	TypeScript guide added — withCycles and reserveForStream with stream_options: { include_usage: true }
Anthropic	Python, TypeScript	TypeScript guide added — streaming via client.messages.stream(), per-tool-call tracking
Groq	Python, TypeScript	New — OpenAI-compatible API, Groq-specific pricing, model-downgrade degradation pattern
AWS Bedrock	TypeScript	—
Google Gemini	TypeScript	—
Ollama / Local LLMs	Python, TypeScript	—

AI Frameworks (10)

Framework	Language	What's new
LangGraph	Python	New — callback handler in graph nodes, per-node scoping, conditional edges with client.decide()
AutoGen	Python	New — model client wrapper for teams, swarms, and graph flows
AnyAgent	Python	New — single callback covers all 7 supported frameworks
LangChain	Python, JS	—
Vercel AI SDK	TypeScript	—
Spring AI	Java	—
LlamaIndex	Python	—
CrewAI	Python	—
Pydantic AI	Python	—

Agent Platforms (3)

Platform	Language
MCP (Claude, Cursor, Windsurf)	TypeScript
OpenAI Agents SDK	Python
OpenClaw	TypeScript

Web Frameworks (5)

Framework	Language	What's new
Next.js	TypeScript	New — route-level guards, server actions, per-tenant isolation
Django	Python	New — middleware, exception handling, per-tenant budget dashboard
Flask	Python	New — error handlers, before_request preflight
Express	TypeScript	—
FastAPI	Python	—

The patterns that matter

Action authority across frameworks

Every integration enforces the same principle: no agent action executes without authorization. Whether it's an LLM call in LangGraph, a tool invocation in AutoGen, or an API request in a Django endpoint — the reservation happens before the action, not after.

This matters beyond cost. The same protocol that prevents a $50 runaway spend also prevents an agent from sending 200 emails, hitting a rate-limited API in a retry loop, or executing a high-risk tool without approval. The OpenAI Agents guide maps tool risk points to budget — send_email costs 50 points while search_knowledge costs zero. The budget authority decides which actions are cheap and which are expensive.

Graceful degradation with model downgrade

Most authorization systems have two modes: allow or deny. Cycles gives you a third: downgrade.

The Groq guide introduces a pattern where agents switch models based on remaining authority:

def chat_with_downgrade(prompt: str) -> dict:
    try:
        return primary_chat(prompt)    # GPT-4o: $2.50/$10 per 1M tokens
    except BudgetExceededError:
        return fallback_chat(prompt)   # Groq Llama 4: $0.11/$0.34 per 1M tokens

The agent keeps working. The user still gets an answer. The authority boundary holds — just with a different cost profile. This works because Cycles tracks authority per action_name, so the budget authority can set different limits for different models and let the application route between them.

Multi-tenant SaaS guide

Beyond integrations, we shipped a comprehensive Multi-Tenant SaaS Guide — the single most-requested doc.

It covers the full lifecycle of per-customer runtime authority:

• Customer onboarding — automated tenant + API key + budget creation
• Plan tiers — Free ($5/mo), Pro ($50/mo), Enterprise ($500/mo) with overdraft limits
• Per-tenant isolation — one customer's runaway agent cannot affect others
• Graceful degradation — upgrade prompts, model downgrade, feature disabling
• Tenant suspension — ACTIVE → SUSPENDED → CLOSED lifecycle

Each customer gets independent spend limits, action boundaries, and risk controls — all enforced at the protocol level with cryptographic tenant isolation.

Try it

Pick your framework from the integration overview, follow the guide, and have budget governance running in under 10 minutes.

If your stack isn't covered, open an issue. We're prioritizing based on real user requests.