CleverThis
Standards-based · A2A-native · built for long-running agents

Build agents.Finish anything.

CleverThis is the agent command center for everyone shipping with LLMs — and everyone using agents to get real work done. Develop, version, deploy, and orchestrate any agent locally or in the cloud, with hierarchical agents and hierarchical actors purpose-built for the long-running, multi-step jobs that flatten single-shot agents. Think of your favorite AI coding tool — minus the “coding-only” ceiling. Self-hostable. MIT-licensed.

Free tier: 1,000 requests / month. No card required.
$ curl the OpenAI-compatible endpoint — same request shape, every provider:
bash
curl -s https://dev.cleverthis.com/v1/chat/completions \
  -H "Authorization: Bearer $CLEVERTHIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Hello!"}]
  }' \
  | jq '{content: .choices[0].message.content, provider: .provider, request_id: .cleverthis.request_id}'

Built by the team behind

McKesson
Siemens
FEMA
U.S. Department of Defense
Schneider Electric
Comcast

From zero to first call in three minutes

No new SDK, no proprietary protocol, no migration script. Sign up, set one environment variable, and your existing OpenAI client (or plain cURL) is now talking to every model provider through CleverThis.

Sign up, grab a key

Free tier: 1,000 requests / month. No card required. Your API key is created automatically on signup and shown once.

ct_live_xxxxxxxxxxxxxxxxxxxxxxxxxx(shown once after signup — copy it to your environment)
Create your account

List available models

Every provider CleverThis supports is exposed through the same OpenAI-compatible model list. One call shows you what is available and what pricing applies.

bash
curl -s https://dev.cleverthis.com/v1/models \
  -H "Authorization: Bearer $CLEVERTHIS_API_KEY" \
  | jq '.data[] | {id: .id, provider: .owned_by, available: .cleverthis.available}'

Make the first call

The gateway routes to the provider you specify, meters the request through OpenMeter OSS, and returns provenance — provider, cost, and request ID — in the same response body.

bash
curl -s https://dev.cleverthis.com/v1/chat/completions \
  -H "Authorization: Bearer $CLEVERTHIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [
      {"role": "user", "content": "What is 2+2?"}
    ]
  }' | jq '{content: .choices[0].message.content, provider: .provider, cost: .usage.cost, request_id: .cleverthis.request_id}'

Features

Each one is a real, working capability — click a tab to see the snippet. Every behaviour shown here is documented in the public specification.

OpenAI-compatible API
Multi-provider fallback
Hosted Actor endpoints
Explainable & auditable
Real-time spend limits
Package registry

OpenAI-compatible API

Every supported provider — OpenAI, Anthropic, Google, Bedrock, Azure, and any BYO endpoint — is accessed through the same POST /v1/chat/completions shape. Streaming, tool calls, JSON mode, and structured outputs all work unchanged.

bash
curl -s https://dev.cleverthis.com/v1/chat/completions \
  -H "Authorization: Bearer $CLEVERTHIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-3-5-sonnet",
    "messages": [
      {"role": "user", "content": "Write a haiku about recursion."}
    ],
    "stream": true,
    "temperature": 0.7
  }'

OpenAI-compatible API

Every supported provider — OpenAI, Anthropic, Google, Bedrock, Azure, and any BYO endpoint — is accessed through the same POST /v1/chat/completions shape. Streaming, tool calls, JSON mode, and structured outputs all work unchanged.

bash
curl -s https://dev.cleverthis.com/v1/chat/completions \
  -H "Authorization: Bearer $CLEVERTHIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-3-5-sonnet",
    "messages": [
      {"role": "user", "content": "Write a haiku about recursion."}
    ],
    "stream": true,
    "temperature": 0.7
  }'

Why CleverThis

Eight things that break the moment you try to run agents seriously. Eight things CleverThis solves at the foundation — every one of them shipped today and documented in the public design record.

Hierarchical agents that actually finish

Single-shot agents bloat their context, retry forever, and stall before the job is done. Hierarchical agents and hierarchical actors decompose hour-long, multi-step work into isolated subtasks — each with its own context window — so the top-level agent stays sharp and the work actually ships.

Develop with CleverAgents. Ship to CleverThis.

CleverAgents is the open-source CLI that mirrors the CleverThis runtime — same actor format, same hierarchical execution, same provider surface. Prototype on your laptop with local models, then push the same actor bundles up to CleverThis when you need scale, observability, and managed infrastructure. The artifacts move unchanged.

Every model. One token. No SDK rewrites.

Swap a single environment variable and your existing OpenAI SDK speaks to OpenAI, Anthropic, Google, Bedrock, Azure, Ollama, vLLM, or anything OpenAI-compatible you point at. Adding a new provider stops being a refactor and starts being a config change.

Versioned, content-addressed agents

Every agent has an immutable SHA-based identity computed from its canonical form. Identical definitions produce identical IDs. Published agents cannot be retroactively altered — so “which version produced that output?” has an answer, every single time.

A real package registry for everything you build

Actors, skills, MCP servers, prompt templates, and graph definitions are first-class versioned packages — not files scattered across notebooks, Slack threads, and someone’s laptop. Share, compose, and depend on agent components the same way you depend on code libraries.

Failover before your users notice

Define an ordered list of providers per request. When the primary 429s, 500s, or rate-limits mid-stream, CleverThis transparently retries the next candidate inside the same response stream. Your users see one answer. You get the telemetry on what actually happened.

Hard spend limits, enforced in real time

A local transactional ledger reserves funds against your wallet before every upstream call. Insufficient balance? The request is rejected with HTTP 402 — before a single provider token is spent. Runaway agents burn nothing they aren’t allowed to.

Use any A2A client. Or our REST. Or our webapp.

Every operation the CleverThis webapp performs is a public A2A JSON-RPC or OpenAI-compatible REST call. Drive the platform from any A2A-compliant client, from our REST API, from the CleverAgents CLI, or from the webapp — you always get the same surface, the same data, and the same permissions. No private endpoints. No lock-in to our UI.


Open standards. Open-source spirit.

CleverThis is built and operated by an open-source shop. We ship with open protocols, publish what we can publish, and give developers honest tools that don’t hold their data or workflows hostage. Security and transparency are first-class concerns: every request produces an auditable trace, every public behaviour is documented in the spec, and every architecture change ships as a public ADR. You can read all of it before you trust any of it.

Built on standards we did not invent

A2A (Agent-to-Agent Protocol)
JSON-RPC control plane

Extensible method namespace, Agent Card discovery. Any A2A-compliant client speaks to CleverThis without a custom integration.

CloudEvents
Usage event envelope

Every metering substrate accepts CloudEvents natively. Your usage data lands wherever you can sink CloudEvents — no proprietary export.

JSON-RPC 2.0
RPC envelope over HTTP

Battle-tested transport for the A2A control plane. No custom framing, no bespoke client SDK to learn.

LangChain
Universal LLM interface

One adapter family covers ~50 providers with uniform streaming, tool-calling, and token-usage extraction.

LangGraph
Bounded graph executor

StateGraph, conditional edges, subgraphs, native streaming. The same runtime substrate the CleverAgents Actors library uses.

OAuth 2.0
Federated sign-in

Sign in with Google or GitHub. No password-management surface to attack when you don’t want one.

OpenAI API
Data-plane schema

Every OpenAI client SDK works as-is — change one base URL and you’re routed through CleverThis.

OpenMeter OSS
Metering and entitlements

Apache-2.0 metering layer, self-hostable. No cloud-only feature lock-in for billing aggregation.

OpenTelemetry
Distributed tracing and metrics

Vendor-neutral observability. Ship traces and metrics to any OTel-compatible backend you already run.

RFC 8785 (JSON Canonical Form)
Content-addressed actor identity

Deterministic canonical bytes for every actor definition, so the same agent produces the same SHA-1 ID anywhere.

Stripe
Payments and checkout

Industry-standard payment processing with webhook idempotency. No bespoke credit-card handling code on our side or yours.

CleverAgents — the MIT-licensed CLI counterpart

CleverThis the hosted platform is a managed service. But the CleverAgents CLI is open source and mirrors much of the CleverThis runtime — same actor format, same hierarchical execution, same provider surface. Use it to develop, run, and self-host agents locally with no account, no telemetry, no strings. Agent definitions move between CleverAgents and CleverThis unchanged.

CleverAgents on Forgejo

What teams are saying

A glimpse of how teams use CleverThis in production. Have a quote you'd like to share? Get in touch.

We swapped three provider integrations for a single CleverThis endpoint in an afternoon. The fallback logic alone has saved us from two outages this quarter — our customers didn't notice either of them.

AR
Aisha RahmanDirector of Engineering, Acme AI

The hosted Actor endpoints are the killer feature. We compile our prompts and chains down to IR, ship a stable URL, and our product team doesn't have to redeploy the app every time a prompt changes.

DL
Diego LarssonFounding Engineer, Stack Loom

Explainable provenance per request was what closed the deal for us. Auditors get exactly what they need without us building a separate logging pipeline. The local self-host story is the icing on the cake.

MO
Mei OgawaCTO, Threadwise

Pay-as-you-go with no per-seat surprises, and a CLI that doesn't fight us in CI. We've been running CleverThis behind every internal LLM workload for six months. Boringly reliable.

JK
Jordan KleinPlatform Lead, Northwind Robotics

Pricing

Start free. Pay only for what you use. Enterprise plans for teams that need SSO, SLAs, or dedicated infrastructure.
Numbers below are preliminary — talk to us before you commit.

Free

$0

forever

1,000 model requests / month
All providers, OpenAI-compatible API
1 hosted Actor endpoint
Community support (CleverAgents Forgejo issues)

Pro

Recommended

$0 base

pay-as-you-go

Unlimited model requests
Provider cost + a small per-request gateway markup
Unlimited hosted Actor endpoints
Stripe-managed top-ups
Email support
All provider fallback features

Enterprise

Custom

contact us

SSO / SAML
Dedicated single-tenant infrastructure
SLA with response-time guarantees
Priority support + on-call escalation
BYO provider keys / private models

Frequently asked questions

CleverThis is an agent command center for developers building with LLMs and for technical teams that run agents on real work. You develop, version, deploy, and orchestrate any agent locally or in the cloud, with hierarchical agents and hierarchical actors built for the long-running, multi-step jobs that flatten single-shot agents. It speaks OpenAI on the data plane and A2A JSON-RPC on the control plane, so existing clients work without rewrites. The open-source CleverAgents CLI mirrors the same runtime locally.

131+ providers are supported out of the box, listed alphabetically below. Plus any OpenAI-compatible endpoint you bring yourself (BYO): self-hosted Ollama or vLLM, an internal fine-tune, a partner endpoint, or any provider we don't list here. Per-request routing rules let you set an ordered preference list across any mix of built-in and BYO providers; failover happens inside the gateway transparently. The full built-in catalog:
  • 302.AI
  • Abacus
  • abliteration.ai
  • AIHubMix
  • Alibaba
  • Alibaba (China)
  • Alibaba Coding Plan
  • Alibaba Coding Plan (China)
  • Amazon Bedrock
  • Ambient
  • Anthropic
  • Atomic Chat
  • Auriko
  • Azure
  • Azure Cognitive Services
  • Bailing
  • Baseten
  • Berget.AI
  • Cerebras
  • Chutes
  • Clarifai
  • Claudinio
  • Cloudflare AI Gateway
  • Cloudflare Workers AI
  • CloudFerro Sherlock
  • Cohere
  • Cortecs
  • Databricks
  • Deep Infra
  • DeepSeek
  • DigitalOcean
  • DInference
  • D.Run (China)
  • evroc
  • FastRouter
  • Fireworks (Firepass)
  • Fireworks AI
  • Friendli
  • FrogBot
  • GitHub Copilot
  • GitHub Models
  • GitLab Duo
  • GMI Cloud
  • Google
  • Google Vertex
  • Google Vertex (Anthropic)
  • Groq
  • Helicone
  • HPC-AI
  • Hugging Face
  • iFlow
  • Inception
  • Inference
  • IO.NET
  • Jiekou.AI
  • Kilo Gateway
  • Kimi For Coding
  • KUAE Cloud Coding Plan
  • Lilac
  • Llama
  • LLM Gateway
  • LMStudio
  • LucidQuery AI
  • Meganova
  • MiniMax (minimax.io)
  • MiniMax (minimaxi.com)
  • MiniMax Token Plan (minimax.io)
  • MiniMax Token Plan (minimaxi.com)
  • Mistral
  • Mixlayer
  • Moark
  • ModelScope
  • Moonshot AI
  • Moonshot AI (China)
  • Morph
  • NanoGPT
  • NEAR AI Cloud
  • Nebius Token Factory
  • Neuralwatt
  • Nova
  • NovitaAI
  • Nvidia
  • Ollama Cloud
  • OpenAI
  • OpenCode Go
  • OpenCode Zen
  • OpenRouter
  • OrcaRouter
  • OVHcloud AI Endpoints
  • Perplexity
  • Perplexity Agent
  • Poe
  • Privatemode AI
  • QiHang
  • Qiniu
  • Regolo AI
  • Requesty
  • routing.run
  • SAP AI Core
  • Sarvam AI
  • Scaleway
  • SiliconFlow
  • SiliconFlow (China)
  • STACKIT
  • StepFun
  • submodel
  • Synthetic
  • Tencent Coding Plan (China)
  • Tencent TokenHub
  • The Grid AI
  • Together AI
  • Umans AI Coding Plan
  • Upstage
  • v0
  • Venice AI
  • Vercel AI Gateway
  • Vivgrid
  • Vultr
  • Wafer
  • Weights & Biases
  • xAI
  • Xiaomi
  • Xiaomi Token Plan (China)
  • Xiaomi Token Plan (Europe)
  • Xiaomi Token Plan (Singapore)
  • Xpersona
  • Z.AI
  • Z.AI Coding Plan
  • ZenMux
  • Zhipu AI
  • Zhipu AI Coding Plan

On Pro, you pay the provider's cost for the tokens you used, plus a small per-request CleverThis fee. Every request is priced against a frozen pricing snapshot, so the cost you see in your usage view is the cost we billed — no surprise reconciliation. Top-ups go through Stripe Checkout; balances are gated by a local transactional ledger in the hot path. If your wallet is empty, requests are rejected with HTTP 402 before any upstream call is made.

An Actor is a versioned bundle of prompts, tools, and chain logic. You author it in YAML (the open CleverAgents Actor format), CleverThis compiles it to an internal IR, and you deploy it as a stable URL. Your application calls the Actor URL with normal HTTP; the runtime executes the IR, handles tool calls, streams the response, and produces a full provenance trail attached to the request log. Actors are content-addressed by SHA-1 of their canonical form, so identical definitions always produce the same immutable ID.

CleverThis (the hosted platform) is a managed service — not open source. But CleverAgents, the CLI counterpart, is MIT-licensed and mirrors much of the CleverThis runtime: same actor format, same hierarchical execution, same provider surface. Use it to develop, run, and self-host agents locally without an account. Both speak the same standards (A2A, OpenAI, CloudEvents) so agent definitions move between them unchanged. Source: git.cleverthis.com/CleverAgents/CleverAgents-core.

Because the data plane is OpenAI-compatible, every OpenAI client SDK works as-is — just point its base URL at CleverThis and use a ct_live_* API key. For control-plane management (workspaces, namespaces, actors, keys, billing), CleverThis exposes a public A2A JSON-RPC surface that the webapp uses itself; any A2A-compliant client, the CleverAgents CLI, or your own HTTP client can drive it with full parity.

CleverThis

CleverThis is a sustainable AI gateway with hosted Actor endpoints — by the team behind CleverThis.

Join the newsletter

Product updates and engineering notes. No spam, ever.