Get an AI line item that cannot exceed its ceiling — governed inference for teams shipping agentic features.

Built for engineering leads who want a budget they can defend. One API, a quality tier, and a hard ceiling enforced in code — no models to manage, no token rate card, no surprise invoice.

The published range for AI subscription plans is 1.1× to 7.0×, and every plan here sits at the top of it. Every figure above comes from the same plan table the product bills from, so it cannot drift from what you pay.

Agent loops do not stop when your budget does

An agentic task burns 10–30× the tokens of a chat query, and a dashboard reports the spend after it happened. That is the arithmetic behind the reported market: 73% of organisations overran their AI budget, one company ran up a $500M month, and an audit of $34M in AI invoices found $1.7M in overcharges — so even the invoice could not be trusted.

Market figures are reported research, not our measurements.

The ceiling, in four parts

Why now, with no countdown

Your un-capped AI spend compounds: reported bills rose ~320% while per-token prices fell ~98%, and unit prices moved 50–94% year over year — so next month's bill is a guess even when this month's volume is known. A ceiling fixes your worst case in both directions: the plan price is the most you can be charged, and falling prices buy you more inference, not less.

Nothing expires today. The only window in the product is the 14-day trial, and it starts when you start. The reason to act is the same every day.

What's your AI feature's worst case?

Pay-per-token vendors can't answer that — their worst case is unbounded, because the bill grows with the workload. Ours is a number, and the calculator works it out from the same plan arithmetic the product enforces.

Four sizes, one rate

Moving up buys a larger allowance and a higher tier — never a cheaper price per unit of inference. If a month runs long, a pack stacks on top without committing you to a bigger plan.

The Ceiling Guarantee

Your invoice never exceeds your plan price. There is no overage, anywhere — a request beyond your allowance is refused before it runs, not billed after. No claim to file. No fine print. The ceiling is enforced in code, on every request, for as long as you subscribe.

And before you pay anything: 14 days free, no card, $2.80 of inference. Bring your own key if you would rather evaluate on your own provider.

The worst case is the price you already agreed to. The best case is that the margin stays yours.

What this is

Questions

Start the free 14-day trial

Free for 14 days, no card, $2.80 of inference — then subscribe or inference stops. Or work out your worst case first: the calculator uses the same arithmetic the product enforces.

Pricing

Four sizes, one rate. Every plan is a monthly AI allowance at a quality level, and moving up buys a larger allowance and a higher tier — never a cheaper price per unit. Prices are per month in US dollars: there is no per-request charge on top, and no overage anywhere in the product.

Every plan includes the command-line harness: the model can read, edit and run things in your project, with every write and every command shown and confirmed first. Tool rounds are ordinary requests — they spend the same allowance, and each one says what it used.

What's your worst case?

Pick the row that covers what you spend today. The worst case is the plan price — a number you agree to before the month starts — and the last column is what that buys at the published rate.

A workload larger than the top row is a conversation — the Enterprise card above is where to start. And if a single month runs long, a pack stacks on top without changing plan.

Every figure here comes from the same plan table the product bills from, so it cannot drift from what you pay.

The Ceiling Guarantee

Your invoice never exceeds your plan price. There is no overage, anywhere — a request beyond your allowance is refused before it runs, not billed after. No claim to file. No fine print. The ceiling is enforced in code, on every request, for as long as you subscribe.

And before you pay anything: 14 days free, no card, $2.80 of inference.

Extra capacity

A pack is extra capacity for a fixed number of days — for a mid-cycle spike, without committing to a bigger plan. It never runs out early, is not transferable, has no cash value, and cannot be withdrawn.

It costs more per unit of inference than a plan does, on purpose. It is a convenience, not a cheaper way to buy.

Questions

Start the free 14-day trial

14 days, no card, $2.80 of inference. Or work out your worst case first — the calculator uses the same arithmetic the product enforces.

What's your AI feature's worst case?

A pay-per-token vendor cannot answer this: their worst case is unbounded, because the bill grows with the workload. This one works it out in about 30 seconds, from the same plan arithmetic the product enforces.

• Enter your monthly requests and average cost per request — or just your current bill.
• See your spend today, your ceiling, and the plan that covers you.
• See what the market's measured trend does to an un-capped line item.

Get the full breakdown

We'll email the calculator and the method behind it, so you have the number and the reasoning. No card, no sales call, and your email is never sold or shared — you can unsubscribe in one click, because "no spam" has to be true, not copy.

See the plans and the packs

Install the client

One command puts clever where your shell will find it: ~/.local/bin, with no node_modules created anywhere. You need Node 22 or newer.

curl -fsSL https://clever.diy/install.sh | sh

That installs clever and clever-mcp, and clever upgrade replaces them from the same place later. Then:

clever login          # opens the keys page and stores one token, 0600
clever doctor         # says what is missing, if anything is
clever chat balanced "summarise this repository"

Point an agent at it

clever-mcp speaks MCP over stdio, so any client that can start a command can use it. It reads the same credentials the CLI does and exposes the same five tools.

Let it edit files

In a conversation the client can read and write files and run commands for you — list_files, read_file, write_file, edit_file and run_command. Reads are automatic; every write and command is shown to you in full and runs only on your yes. The tools are on in a conversation, and a tool that is not a terminal gets refused rather than answering a confirmation nobody can see.

Other ways in: the quickstart takes the API directly.

Documentation

One base URL, one key, and a tier instead of a model name.

No section mentions that. Try a shorter word.

Quickstart

from openai import OpenAI

client = OpenAI(base_url="https://api.clever.diy/v1", api_key=os.environ["CLEVER_TOKEN"])
client.chat.completions.create(
    model="balanced",  # the tier, where a model name would otherwise go
    messages=[{"role": "user", "content": "Hello"}],
)

curl https://api.clever.diy/v1/infer \
  -H "authorization: Bearer $CLEVER_TOKEN" \
  -H "content-type: application/json" \
  -d '{"tier":"balanced","messages":[{"role":"user","content":"Hello"}]}'

That is the whole shape: a tier, and messages. There is no model parameter, because naming a model is the promise this API exists to replace.

Authentication

An API key in Authorization: Bearer. Issue and revoke keys from your keys page. A signed-in browser session works too — the cookie is set at sign-in and the same endpoints accept it, which is how this site works.

Tiers

A request names a tier, never a model. Three exist:

Your plan decides which tier you may ask for. Asking above it is never refused: the request is served at your plan's own tier and x-clever-tier names the tier that actually ran — so the answer is never a guess, and never silent. Your tiers and how many models sit behind each are at GET /v1/me/tiers.

Inference

Images, speech and video

What a response tells you

Every response carries which model served it and what is left of your monthly allowance, so you never have to guess.

When something is refused

A refusal is a normal answer with a reason and, where it applies, a upgradeRequired flag.

Here is one in full, because a refusal should be readable without opening a support ticket. This is the answer to naming a model instead of a tier:

{
  "error": "model_not_addressable",
  "detail": "name a tier instead: budget, balanced or max",
  "tiers": ["budget", "balanced", "max"]
}

Every wall carries the same four things: which bound you hit, what the numbers were, how much is left, and whether buying fixes it. upgradeRequired is that last one — a refusal that says "wait" when the remedy is a plan change is a refusal that wastes an afternoon.

What happens when you reach your limit

Each plan includes a monthly allowance. It is yours for the whole month, and it resets on the first of the month — not 24 hours after you signed up.

When a request would exceed it

The request is refused, not billed. You get a 429 and a reason you can read. Nothing is charged beyond what you have already used, and there is no overage on your next invoice.

Three ways forward, and none of them is waiting:

• Wait for the month to reset, if you can.
• Add a pack — extra capacity for a fixed number of days, straight from your dashboard. It costs more per dollar of inference than a plan does, on purpose, so it never quietly becomes the cheaper option.
• Move up a plan, which carries a larger allowance.

What we will never do

• Overage. There is no metered charge above your allowance.
• A bill you did not expect. What you see in your dashboard is what you owe.
• Silently substituting. Ask above your plan and x-clever-tier says which tier ran; ask for the tier you bought and, if no model can serve it, the request is refused rather than quietly served by something worse.

The other limit

There is also a requests-per-minute figure, to stop a runaway loop from taking the service down for everyone. It is not a spending limit and you are very unlikely to reach it. If you do, the error says so and asks you to slow down.

Managing your account

The same key, on your own account.

Bring your own provider

If you would rather run on your own provider account and your own key, two calls connect it and use it. Your Clever allowance is not involved at all: you are paying that provider directly, so there is nothing here for us to spend.

# 1. Connect the provider. The key is held in memory for a TTL, then gone.
curl https://api.clever.diy/v1/me/sessions \
  -H "authorization: Bearer $CLEVER_TOKEN" \
  -H "content-type: application/json" \
  -d '{"baseUrl":"https://api.openai.com/v1","apiKey":"$YOUR_PROVIDER_KEY"}'

# 2. Infer through it. Here you *do* name a model: it is your provider and your key.
curl https://api.clever.diy/v1/me/infer \
  -H "authorization: Bearer $CLEVER_TOKEN" \
  -H "content-type: application/json" \
  -d '{"sessionId":"ses_...","model":"your-providers-model-id","messages":[{"role":"user","content":"Hello"}]}'

• The key is never stored and never returned. The session holds it in memory for a TTL, and what you can read back is the host — nothing more.
• Naming a model is allowed here, and only here. On the managed path a tier is the promise; on your own provider there is nothing for us to curate.
• It is rate-limited, not budgeted. What is bounded is how fast one key can be used through us, because the money being spent is yours.
• GET or DELETE /v1/me/sessions/:id inspects or ends it. A session that is not yours answers 404, not 403 — an error that confirms a key exists is an error that helps someone guess.

The harness

The command line is not only a chat: it works on the project you run it in. Run clever in a folder, ask for a task, and the model can list and read files, write and edit them, and run commands — on your machine, in the directory you started it in. There is nothing to switch on; --plan is the one flag that takes the write tools away.

You see everything first. Listing and reading are automatic — except a credential, which asks first, because its contents would become part of the conversation and the transcript; a write or a command is shown in full — the diff, or the exact command and where it would run — and runs only when you say so. Answering always remembers that exact command, or that exact file, for that project, and the list lives outside your repository, under ~/.local/state/clever/permissions/.

It stays in the project. A path outside the directory you started in is refused, symlinks included, and --allow-outside is the explicit way to say otherwise. A command's output is capped and the process is killed after a timeout, so a build log cannot become the next prompt.

Bring your own tools. If you use MCP servers, their tools are offered to the model beside Clever's own five — and they ask the same way: the whole call is shown before it runs.

Your files go nowhere but the prompt. A tool result is a message to the model on the same channel your own question uses, under the same allowance — no upload, no index, no telemetry. The loop runs on your machine, and the server never executes anything.

clever chat --tools balanced "add a --quiet flag to src/cli.ts and run the tests"
    clever chat --tools balanced --continue "and document it in the README"

Included with every plan, because tool rounds are ordinary requests: the metering line after each one says what it used. --plan is the same turn read-only, for looking around without changing anything.

Status

Checks that ran just now, against our live endpoints.

What each refusal means, and what fixes it

Your account

Where your allowance stands and what you've been using.

Your allowance

What you've been using

Last requests

Plans

A payment is confirmed by the processor and can take a moment to appear here.

Extra capacity

Playground

A real request against your own allowance, streaming as it arrives. This is the same endpoint your key calls, so whatever it costs is charged to your plan.

Members

Everyone here shares one allowance and one bill. Invite a colleague with the address they will sign in with.

An invitation is a link that works once and expires in seven days. Joining puts them on this workspace — their requests come out of the same allowance as yours.

People

Pending invitations

Back to your dashboard

Join a workspace

Choose a password and you are in. You will be signed in straight away, on the account that invited you.

API keys

Create a key for each place you use Clever — one for production, one for local development — so revoking a leaked key doesn't take everything down with it.

A key is shown once and cannot be read again. If you lose it, revoke it and create another; nobody, including us, can recover it. Your key is scoped to your account, so one account cannot spend another's allowance.

Back to your dashboard