Cloudflare Clef for Startups: How Decision Models Cut Your AI Agent Costs (2026 Guide)

Real talk: most AI agents are burning money on decisions that never needed a full-blown LLM.

Think about it. Your support bot gets a ticket. Before it can do anything useful, it has to answer two dumb questions: is this urgent, and which team owns it? Right now, most teams burn a full GPT- or Claude-class call — hundreds of milliseconds, a fistful of output tokens, a response you then have to parse with regex and prayer — just to get “yes” and “billing.”

Cloudflare thinks that’s silly. And on October 1, 2026, they shipped something to fix it: Clef and Clef-flash, the first models Cloudflare has ever trained in-house. They’re not chatbots. They’re decision models — a whole new model category that’s about to show up everywhere in your stack. I dug into the launch docs and the numbers, and honestly? This is one of the most founder-relevant releases of the year. Let me show you why.

What a decision model actually is

Here’s the mental model that made it click for me.

A regular if statement works when your code can compute the condition: if (order.total > 100). Easy. But it falls apart the moment the condition needs understanding. Is this support message urgent? Which team should handle it? Does this screenshot show a password?

The usual answer is to ask an LLM and parse whatever it writes back. A decision model skips the writing entirely. You hand it two things:

1. A state — the ticket, the page, the agent trace, whatever you’re deciding about.
2. Typed questions — the exact questions you need answered, with the allowed answers defined up front.

And it returns probabilities. Not sentences. Numbers your code can branch on immediately: urgent: 0.94, team: billing (0.81). No parsing, no reasoning tokens to wait for, no “as an AI language model” surprises.

Clef supports three question types, inherited from the System One API that Typesafe’s Jev introduced:

• noul — a yes/no question. Returns the probability the answer is yes.
• choice — pick one option from a set you define. Returns the winner, a probability per option, and a confidence value.
• score — rate something against an ordered rubric. Returns a probability-weighted score and a probability per level.

You can ask up to 64 questions in a single request, and unlike text-only decision models, Clef has a vision encoder — up to 4 images per request. Classify, score, and gate, all in one call.

What Cloudflare just launched

Two models, announced during Cloudflare’s Birthday Week and live on Workers AI now:

• Clef — 27 billion parameters, built on Qwen3.8-27B. The accuracy pick: 209.3 ms median latency, $0.24 per million input tokens.
• Clef-flash — 9 billion parameters, built on Qwen3.5-9B. The speed pick: 38.8 ms median latency, $0.09 per million input tokens.

Both get a 64K-token context window, and here’s the pricing detail I love: output tokens are not billed at all. Since the model never writes paragraphs back, your costs are bounded and predictable — a welcome change if you’ve ever watched an agent’s token bill spiral. (Pricing confirmed via CryptoBriefing’s launch coverage.)

The weights are open-sourced under the Apache 2.0 license on Hugging Face, so you can self-host later. API first, self-host when it matters — no lock-in anxiety.

Clef vs Clef-flash: which one do you need?

Honestly, most startups should start with Clef-flash. Decisions that need to happen in the hot path — gating a tool call, routing a ticket, classifying an upload — want the 39 ms model, and the accuracy gap is small (Clef-flash still beat Jev on most benchmarks). Reach for full Clef when the decision is high-stakes and you can afford 200 ms: fraud-adjacent calls, trust-and-safety scoring, anything where a wrong branch is expensive.

Cloudflare also launched an RL fine-tuning service alongside the models — you can capture your own decision data and tune Clef for your workload. Right now it’s rolling out through design partners with hands-on support, so file that under “coming soon for the rest of us.”

The money part: a real cost comparison

Let me make this concrete, because “cheaper” doesn’t mean much without numbers. Say your startup handles 10,000 support tickets a month, and each ticket currently costs you one mid-tier LLM call to triage — roughly 500 input tokens in, 60 output tokens out, at something like $3/$15 per million. That’s around $24/month just to answer “is this urgent and whose is it.”

Now run the same triage through Clef-flash: ~500 input tokens at $0.09 per million, zero output billing. That’s about $0.45/month. For ten thousand decisions.

Is $24 a lot? No. But that’s one decision type, on one workflow, at small volume. Real agents make dozens of micro-decisions per task — “should I call this tool?”, “is this argument grounded?”, “which branch next?” — and at 10x volume you’re choosing between hundreds of dollars and pocket change. If you’re serious about cutting your AI API bill, decision models are the architectural move that makes the biggest dent: they let your expensive LLM act only on the decisions that actually need judgment.

Cloudflare’s own example is telling: paired with Browser Run, Clef fetched, rendered, and classified a domain in 2.2 seconds, versus 4.7 seconds for gpt-oss-120b doing the same workflow. Faster and cheaper is a rare combo — usually you pick one.

Hands-on: build a support triage router with Clef

Okay, the practical part. This is the pattern from Cloudflare’s launch docs, adapted for a startup’s support inbox. You call Clef through the Workers AI binding (env.AI.run()) or the REST endpoint — either way, the shape is the same:

const response = await env.AI.run("@cf/cloudflare/clef-flash", { state: ticket.text, // the raw support message questions: { urgent: { type: "noul", instructions: "Is this support request urgent? Treat outages, data loss, and angry enterprise customers as urgent." }, team: { type: "choice", instructions: "Which team should handle this request?", criteria: { billing: "Payments, invoices, and refunds", technical: "Outages, errors, and configuration", sales: "Plans and upgrades" } }, sentiment: { type: "score", instructions: "Rate the customer's frustration from 1 (calm) to 5 (furious)." } } }); // Three questions, one call, ~40 ms: if (response.answers.urgent.noul > 0.8) pageOnCall(ticket); routeTo(response.answers.team.choice); // "billing", plus per-option probabilities if (response.answers.sentiment.score >= 4) addPriorityFlag(ticket);

A few things to notice. First, three questions cost one call — you get 64 per request, so batching related decisions is free. Second, the thresholds are yours: 0.8 for paging, 0.6 for auto-route, anything below goes to a human queue. That calibration is the real work — run a few hundred of your own tickets through it, look at where the probabilities land, and set your cutoffs from data, not vibes. Third, this is the exact API shape Typesafe’s Jev uses, so if you already built on Jev, switching is mostly changing the endpoint and model name (Flavio Copes has a good hands-on deep dive with real outputs if you want to see the responses).

And look — if reading that code made your eyes glaze over, that’s fine. Not every founder needs to wire this up personally. If you’d rather have someone else build the agent plumbing into your product, AISquadX is an AI integration studio that does exactly this kind of work. But the pattern is simple enough that a weekend and a Cloudflare account gets you a working prototype.

Where decision models fit in your startup’s stack

Cloudflare’s launch post lists five use cases, and they map neatly onto things startups actually build:

• Support triage — decide urgency and ownership, route without a human in the loop. If you sell AI services to local businesses, this is a product you can ship this month.
• Agent guardrails — let an agent ask “should I take this action?” in tens of milliseconds before calling a tool. This is the one I’m most excited about: a 39 ms safety check that runs before every expensive or irreversible action.
• Trust and safety — score user submissions against your own policy rubric and act on the probability. The score question type was basically made for this.
• Threat intelligence / classification — categorize websites, screenshots, or uploads. Clef’s vision encoder (4 images per request) puts it ahead of text-only decision models here.
• Workflow routing inside automation — if your automation stack has branches that need judgment calls, a decision model is a cleaner fit than an LLM step with parsed output.

When NOT to use a decision model

Honesty check, because the hype will tell you these replace LLMs. They don’t.

• Anything open-ended. If you can’t enumerate the possible answers up front, you don’t have a decision problem — you have a generation problem. Use an LLM.
• Decisions that need explanation. Clef gives you probabilities, not reasons. If your users (or your auditors) need to know why, you still need a model that can show its work.
• Your first 100 tickets. Decision models shine at volume. If you’re pre-product-market fit and handling 20 tickets a day, the $24/month LLM triage is fine. Optimize the product first.
• Brand-new decision types with no calibration data. Probabilities are only useful once you’ve validated them against your own data. Cloudflare’s benchmarks are a starting signal, not a guarantee — run your own evals.

The field is moving fast: Jev, OpenAI, and AWS all want this

Clef didn’t arrive in a vacuum — the “decision model” category went from zero to crowded in about two weeks. Here’s the scorecard:

Model	Who	When	Key facts
Jev	Typesafe	Sept 15, 2026	The original. Defined the System One API that Clef copies. Text-only, 524 ms median latency.
Decisions API	OpenAI	Sept 29, 2026	Limited preview. Closed, naturally — no open weights.
Clef / Clef-flash	Cloudflare	Oct 1, 2026	Open weights (Apache 2.0), vision support, 39–209 ms, cheapest pricing of the bunch.
Strands Decider 2B	AWS / Strands Labs	Oct 1, 2026	2B params, open weights and training scripts, designed to run locally for gating decisions.

That’s four serious entries in sixteen days. When big tech converges this fast on one idea, it’s usually because the economics are obvious: micro-decisions are the highest-volume, lowest-margin LLM calls in every agent, and whoever owns the cheap layer owns a toll booth. For a startup, the practical read is simple: build your decision layer on an open API shape (System One), because you can swap Clef, Jev, or whatever comes next without rewriting your code.

“A decision model is analogous to a music clef because it helps define the domain of the context and the subsequent notes (actions) that follow it.” — Cloudflare, on the naming, in their launch announcement

What I’d watch out for

Three honest caveats before you go all-in:

1. The benchmarks are Cloudflare’s own. Clef leads on 7 of 10 decision benchmarks they tested, with BANKING77 macro-F1 of 94.20 against Jev’s 79.74 and BFCL case-exact of 98.47/98.76 against 95.75. Impressive — and also exactly what you’d expect a vendor to report. The numbers are a reason to try it, not a reason to skip your own evaluation. Run a few hundred of your own examples through both models before you commit a production path to either.

2. The RL fine-tuning service isn’t self-serve yet. Tuning Clef on your own decision data is the feature that could make this a real moat for your product — a model that learns your triage patterns. But right now it’s design partners with forward-deployed engineers. If that’s the part you wanted most, you’re waiting in line.

3. The ecosystem is two weeks old. Tooling, best practices for calibration, prompt patterns for the question types — all of it is being invented right now. Early adopters get the cost advantage; they also get to be the ones who discover the sharp edges. Start with a non-critical path (triage suggestions, not auto-actions) and promote to auto-pilot once you’ve seen a month of real probabilities.

FAQ

What is a decision model?

A decision model is an AI model that answers fixed, typed questions with probabilities instead of generating free-form text. You give it a state (like a support ticket) and questions (like “is this urgent?”), and it returns structured answers your code can act on immediately — no parsing required.

How much does Cloudflare Clef cost?

Clef costs $0.24 per million input tokens and Clef-flash costs $0.09 per million input tokens. Output tokens are not billed at all, which makes costs highly predictable. Both models are also available as open weights under Apache 2.0 if you’d rather self-host.

What’s the difference between Clef and Clef-flash?

Clef is the 27B-parameter model optimized for accuracy (209 ms median latency); Clef-flash is the 9B-parameter model optimized for speed (39 ms median latency). Both share a 64K context window, vision support for up to 4 images, and up to 64 questions per request. Start with Clef-flash for latency-critical paths and use Clef for high-stakes decisions.

Is Clef compatible with Typesafe Jev?

Yes. Clef follows the System One API that Typesafe’s Jev introduced, so an existing Jev integration can switch to Clef by changing the endpoint and model name. Clef adds vision support (Jev is text-only) and reports lower latency on Cloudflare’s benchmarks.

Should my startup replace LLMs with decision models?

No — that’s the wrong framing. Decision models handle the high-volume micro-decisions (routing, gating, scoring) for pennies, and your LLM handles the 5% of cases that need real judgment or explanation. The winning architecture is a cheap decision layer in front of an expensive reasoning layer, not one or the other.

The Bottom Line

Here’s the thing about Clef: it’s not the flashiest launch of the week. It doesn’t write poetry or pass the bar exam. It just answers “yes, 94%” in 39 milliseconds for a fraction of a cent — and it turns out that’s what most of your AI agent’s budget was actually being spent on.

If you’re building agents, the move is straightforward: put Clef-flash in front of your expensive LLM calls as a decision layer, calibrate the thresholds on your own data, and watch a whole category of token spend evaporate. The weights are open, the API is a known shape, and the category now has four serious players — which means you’re not betting on one vendor’s experiment, you’re adopting a pattern the whole industry just agreed on.

Well — mostly agreed on. The benchmarks are still vendor-supplied, the fine-tuning is still gated, and somebody’s going to find the sharp edges first. Just make sure it’s not you finding them on your most critical workflow. Start with triage suggestions, graduate to auto-pilot, and keep the receipts.