Summary: Cloudflare announced a preview of Clairic on October 19, 2026, the first of what it calls System One extraction models, hosted on Workers AI as @cf/cloudflare/clairic. Unlike an LLM, it returns typed values — extracted, computed, estimated, or forecasted — from a single forward pass with no output tokens, and Cloudflare says it will release the weights openly. If you build extraction pipelines today, this changes what the failure modes and the bill look like.
Why extraction needed its own model class
The framing comes from Daniel Kahneman’s Thinking, Fast and Slow, popularized recently by TypeSafe’s Jev model: System One models are fast and precise, System Two models (LLMs) reason deliberately. Until Clairic, every System One model was a decision model — Jev and Cloudflare’s own Clef take an input state plus a list of options and return probabilities. I looked at how Clef puts decision models in the agent hot path; Clairic covers the other half of the problem.
Extraction is arguably the most common job handed to LLMs: “return the invoice number, vendor, and due date as JSON.” It mostly works, but the failure modes are expensive to catch — invalid JSON, a digit corrupted during generation, and no way to trace a returned excerpt back to its position in the source. Teams bolt on parsing, schema validation, retries, and spot checks, and pay reasoning and output tokens on every field of every document.
How Clairic answers
A request is a state (text plus up to four images) and a map of typed fields. Each field gets a name, a type, and optional plain-language instructions. Supported types include text (a span with character offsets), number, date/time/datetime, duration, list, estimate (a distribution within your declared bounds and grid), and forecast (one estimate per future step). Every scalar answer carries a p_null probability and a confidence score; estimates come with a median and an 80% interval.
Because everything computes in one parallel pass, there are no output tokens to generate or bill for. Asking for thirty fields costs roughly the same as asking for three, and responses typically arrive in under a second, versus several seconds for an LLM reasoning through the same step. If your fields don’t fit beside the input in one pass, the server splits them across parallel passes and merges the answers.
What a request looks like
Cloudflare’s example processes a damaged-order support email. From a Worker:
const { answers } = await env.AI.run("@cf/cloudflare/clairic", {
state: email,
fields: {
order_id: { type: "text", instructions: "Order number" },
delivered_on: { type: "date", instructions: "Delivery date" },
amount_paid: { type: "number", decimals: 2, unit: "USD", instructions: "Total paid including tax" },
days_since_delivery: { type: "duration", unit: "days", integer: true, instructions: "Days from delivery to the date the customer wrote" },
damage: { type: "list", items: "text", instructions: "Each kind of damage described" },
},
});The interesting parts of the response: amount_paid isn’t written anywhere in the email — the model added price and tax in the same pass. days_since_delivery is computed from two dates. The damage list comes back as exact character spans, so you can highlight them in the source. And when asked for a tracking number that isn’t in the email, it returns null with a p_null of 1, plus a low-confidence guess — instead of a plausible-looking fabrication.
Because it generates no tokens, it can’t produce a mistyped answer the way an LLM can — though it can still be wrong, which is what the confidence scores are for.
Where it fits in your stack
Cloudflare positions the three model types as a pipeline: extraction models turn raw input into typed values, decision models turn values into decisions, and LLMs turn decisions into words. That maps cleanly onto the architecture questions I covered in the 2026 structured data extraction guide — most agent stacks today are paying System Two prices for what is really System One work.
Practical caveats: it’s a preview hosted on Workers AI, so you’re coupled to that runtime until the promised open-weights release. Accuracy claims (higher accuracy and lower cost than LLMs) are Cloudflare’s own, not independently benchmarked. The sensible next step is to take your current LLM-based extraction prompt, restate its fields as a typed field map, and compare outputs and costs on a sample of real documents — the confidence and p_null scores give you a direct way to route low-certainty fields to a fallback model or a human.
Sources
View the original post on X