Choosing a Decision API in 2026: My Practical Framework

Image placeholder

Editorial, product-forward hero illustration on an off-white background — a clean, flat vertical decision tree that reads top-to-bottom. Five labeled gates in sequence, each as a rounded rectangle in pale slate with navy ink: 'REQUEST FORMAT?', 'IMAGES?', 'CONTEXT LENGTH?', 'CALIBRATION?', 'LICENSING?'. One thin emerald-green vertical rule connects the gates. From the final gate, five short branches fan out to five rounded tiles on the lower band, each a soft shade (pale slate, pale emerald, pale blue, pale sand, pale slate), labeled with a use case in small navy caps: 'LOWEST COST', 'HIGHEST QUALITY', 'MULTIMODAL', 'LONG DOCUMENTS', 'SELF-HOSTED'. A short tagline sits above the tree: 'five questions, five picks, one default'. Clean, flat, geometric. Palette: off-white background, pale slate borders, one emerald accent, navy ink for all labels. Linear or Stripe editorial feel. No AI robots, no neural networks, no brains, no faces.

• Aspect ratio: 16:9
• Source size: 1600 × 900 px (sharp on retina at 760 px display width)
• Format: WEBP (preferred), PNG fallback
• Target file size: under 300 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

By Dr. Sanju Abraham, Fractional CTO — 180+ projects shipped, 34 funded companies. Published October 16, 2026.

Key takeaways

• Picking a decision API in late 2026 is a product decision, not a model-ranking exercise. Thirteen vendors ship something decision-shaped; the useful move is a short, repeatable framework instead of a benchmark war.
• Five questions decide ninety percent of the choice. Request format, image needs, context length, calibration quality, and licensing — asked in that order — rule most vendors out of a given workload before you ever load a benchmark chart.
• There is a short pick for each major use case. Lowest cost, highest quality, multimodal, long documents, and self-hosted each map cleanly to one or two of the thirteen vendors I tracked in the first month of the category.
• I keep Jev as my default while I test the alternatives. It is cheapest among hosted, it defined the request shape most others copy, and sitting on it keeps a thin provider adapter honest.
• The best time to swap is after a dual-write pilot, not after a vendor pitch. Every pick in this piece assumes a one-file adapter and a week of shadow traffic as the actual decision procedure.

The short answer: In late 2026, choosing a decision API is a two-step procedure. First, run the inputs through five questions — request format, images, context length, calibration, licensing — and keep only the vendors that survive all five for your workload. Second, line those survivors up against five short picks keyed to use case — lowest cost, highest quality, multimodal, long documents, self-hosted — and pick on fit, not on a chart. I call that two-step procedure the five-question framework, and this piece is the capstone that walks it end to end. For the full vendor landscape it operates on, see the thirteen-decision-API market map.

A CTO pinged me this week. “We have budget to pick one decision API for Q1. I have read your series. I just need the framework.” Fair ask. The previous nineteen posts have the receipts; this one has the recipe. If you have been following along, treat it as the one-page reference. If you have not, start here and come back.

Why do you need a framework at all?

Because thirteen vendors shipped something decision-shaped in thirty days and no single benchmark will separate them for your workload.

Nine months ago, picking a decision model meant picking Jev or waiting. Today the choice set includes TypeSafe Jev, OpenAI’s Decisions API, Microsoft’s Decision-1 in Azure AI Foundry, Cloudflare’s Clef and Clef-flash, Liquid AI’s d1 family, Upstage’s Solar Decide, Nace.AI’s Drex, Celeris-1, Perplexity’s structured outputs, Mistral’s Classifier Factory, AWS Strands Decider 2B, ConvAI’s Laya, SemIF, and DJev. That is fourteen names before you count the entrants I expect by January. For the full landscape, the companion piece is 13 Decision APIs in 3 Weeks: A Builder’s Map of the Market.

A benchmark war will not solve this. Vendor-run charts are, in my experience, somewhere between misleading and useless — I spent a whole article on how to read them in Be Careful With “Beats Jev”. What actually scales is a short checklist you apply to every new vendor pitch and every production workload. Five questions, in a fixed order, each with the power to eliminate most of the field in one sentence.

The five-question framework, in order

Ask these five questions, in this order, for every workload. The order matters: each question is cheaper to answer than the next, so the earliest “no” saves the most time.

• Question 1 — Request format. Does this vendor accept Jev’s POST /v1/systemone body wire-compatibly, use its own request shape, or ride a general-purpose structured-output API? Wire compatibility is not optional nicety; it is the difference between a one-line swap and a one-sprint migration.
• Question 2 — Image input. Can the model see pictures, or is it text-only? If your workflow is receipts, screenshots, document extraction, or visual moderation, half the field drops out at this gate.
• Question 3 — Context length. Will the input fit? Most hosted decision models cluster between 32K and 64K tokens; a few go further. If you are rating a 200K-token contract or triaging a long chat history, this question eliminates most of the field.
• Question 4 — Calibration. Does the model’s reported confidence actually match reality at the thresholds you plan to automate at? If you cannot answer this with numbers from your own data, treat the vendor as unproven for high-volume automation.
• Question 5 — Licensing. Does the license let you deploy where you need to deploy, keep the data where it needs to be kept, and run at the scale you plan to run at? Apache 2.0 and MIT are easy; OpenRAIL, Llama community license, and bespoke “research-only” tags are not.

Answer the five questions, in order, before any demo. Any vendor that fails a question is out for that workload. Any vendor that passes all five moves to the short picks below. This is the whole framework.

Question 1: Which request format are you buying into?

Request format is the single most load-bearing choice because it sets your switching cost for the next twelve months. Pick the camp first, pick the model second.

Three camps emerged in the first month of the category, verified in the one-line migration piece.

• Jev-compatible endpoints. TypeSafe Jev, Liquid AI’s d1, Nace.AI’s Drex, Celeris-1, and Upstage’s Solar Decide all accept the same POST /v1/systemone request body. Swapping between them is a base-URL change plus a key. If you want vendor freedom at the lowest possible engineering cost, start here.
• Own-endpoint vendors. OpenAI’s Decisions API, Microsoft’s Decision-1, and Cloudflare’s Clef family each ship a first-class decision product on their own request shape. They are not wire- compatible with Jev; they are not trying to be. The bet is that your team already pays one of these cloud bills, in which case integration friction is lower than any benchmark gap. See OpenAI, Microsoft and Cloudflare joined in.
• Structured-output surfaces. Perplexity sonar with response_format, Amazon Bedrock with JSON Schema outputs, and Mistral’s Classifier Factory are not framed as decision products, but a schema with an answer enum and a confidence field returns the same typed answer. The ceiling is lower — no native calibrated probability — but the shape fits, and you probably already have the key.

Pick the camp before the vendor. Once the camp is picked, the three to five remaining vendors fit on one short list.

Question 2: Do you need the model to see pictures?

Image input is a binary that splits the field roughly in half. If you need it, the short list collapses fast.

As verified in the market map, three product lines accept images as of October 2026: Cloudflare’s Clef and Clef-flash (up to four images per request), OpenAI’s Decisions API (on GPT-6 Luna), and Liquid AI’s d1-omni-600M variant. Perplexity sonar, Bedrock, and Mistral inherit whatever modality their base model supports. Everything else — Jev, Upstage Solar Decide, Microsoft Decision-1, Laya, SemIF, DJev, AWS Strands Decider 2B — launched text-only.

A pragmatic test. If your workflow is receipts, invoices, document extraction, screenshots, or visual moderation, your three candidates are Clef, Clef-flash, and OpenAI’s Decisions API. If text alone is fine, do not pay for pixels you will not use. For the broader placement question — where this image gate sits inside an agent — see where decision models fit in an agent stack.

Question 3: How long is a typical input?

Most hosted decision models cluster between 32K and 64K tokens of context, with a few extending further. If your inputs are small, this gate ignores most of the field. If they are not, it eliminates most of the field.

The honest 2026 reading:

• Up to 64K tokens. Jev, Clef and Clef-flash, OpenAI’s Decisions API, and Microsoft Decision-1 all sit in the 32K-to-64K band. Fine for emails, tickets, pages of PDF, product descriptions.
• Beyond 64K. Upstage Solar Decide’s catalog listings describe a 512K-token context window on its decision endpoint. If your workload is “rate this 100-page contract” or “triage a long chat history,” it is reportedly the only Jev-compatible choice that fits in a single call without chunking.
• Chunking as a fallback. Any vendor can be used on long inputs by splitting and voting, but you pay for the pattern in latency, accuracy, and engineering time. Prefer a single-call fit when one exists.

I will say “reportedly” on Upstage’s 512K number because I have not measured it on real traffic — the vendor warns the schema may still shift before general availability. Treat it as the right order of magnitude rather than a guarantee.

Question 4: Is the model actually calibrated?

A model whose “0.80” means 80% in production is more useful than a model whose “0.95” means 72%. Calibration is the number that decides whether your three-band automation actually works.

I spent a full article on this gate in calibration is the feature nobody is talking about. The short version:

• Reported numbers put Clef near 0.040 Expected Calibration Error and Jev near 0.074 on vendor-adjacent benchmarks, which is already a meaningful spread. Both are decent; neither is a disaster.
• Vendor numbers are vendor numbers. Run the one-afternoon honest-confidence test on your own data before you build any three-band routing on top of a confidence score. The three-band framing itself is in why “70% sure” beats “yes”.
• Re-check calibration after every prompt or model change. It is not stable across versions, and the week you ship a new prompt is the week your thresholds silently drift.

If your product automates above a confidence threshold, calibration beats accuracy. Treat this question as a gate, not a tiebreaker.

Question 5: Does the license let you ship?

Licensing is the last question because it has the sharpest teeth. A workload that passes the first four gates can still be killed by one clause in a license you did not read.

The relevant distinctions in October 2026, verified in open-weight decision models:

• Apache 2.0 / MIT. Cloudflare’s Clef and Clef-flash, AWS Strands Decider 2B, and SemIF all ship under genuinely permissive licenses. You can deploy them in your VPC, fine-tune them, embed them in a commercial product, and move on.
• Hosted-only. TypeSafe Jev is hosted-only — the weights are not released, so compliance teams who need the model inside their own perimeter have to pick a Jev-shaped open-weight model instead. OpenAI Decisions, Microsoft Decision-1, Upstage Solar Decide, and Perplexity sonar are also hosted-only.
• OpenRAIL and bespoke terms. Some entrants ship under OpenRAIL variants that add behavioral use restrictions, or Llama-style community licenses with scale triggers. Read the license before you build on it. The headline “open-weight” does not always mean “open”.

If your workload has data-residency or air-gap requirements, Questions 1 through 4 narrow the camp; Question 5 picks the actual model.

Image placeholder

A clean, five-column scorecard infographic on an off-white background. Columns are labeled from left to right: FORMAT, IMAGES, CONTEXT, CALIBRATION, LICENSE. Rows list five vendors across the top: Jev, OpenAI Decisions, Clef, Solar Decide, Laya. Each cell contains a simple pass/fail/caveat glyph in a soft shade — pale emerald filled circle for pass, pale slate outline circle for 'caveat', pale sand outline square for 'does not apply'. A short title line reads 'the picker's checklist, filled in'. Palette strictly off-white background, pale slate grays, pale emerald accent, pale sand accent, navy ink. Linear or Stripe editorial feel. No AI robots.

• Aspect ratio: 16:9
• Source size: 1280 × 720 px (sharp on retina at 760 px display width)
• Format: PNG
• Target file size: under 500 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

The short picks: one vendor per use case

Five use cases. One recommended vendor each. Caveats where the numbers are vendor-reported.

Use case	Pick	Why	Caveat
Lowest cost (hosted)	TypeSafe Jev	$0.042 per million input tokens, output free. Lowest published hosted number in the category.	Text-only; 32K-64K context; hosted-only license.
Highest quality (general)	OpenAI Decisions API or Microsoft Decision-1	Both ride frontier bases (GPT-6 Luna, Microsoft’s Foundry Decision-1). OpenAI charges $0.10 per million input tokens; Microsoft’s Decision-1 announcement lists a 32,768-token window with calibrated probability.	Vendor-run accuracy claims — verify with your own data per the three-asterisk rule.
Multimodal (images)	Cloudflare Clef or Clef-flash	Up to four images per request, 64K context, Apache 2.0. Clef-flash reportedly $0.09 per MTok; Clef reportedly $0.24.	Prices “reportedly” — vendor-adjacent sources, verify before committing.
Long documents (>100K)	Upstage Solar Decide	Vendor-reported 512K-token context; Jev-compatible wire format at $0.10 ($0.05 on OpenRouter).	Vendor flags the schema may shift before GA — treat as a 90-day window.
Self-hosted (VPC, air-gap)	Cloudflare Clef (open-weight) or ConvAI Laya	Both ship Apache 2.0 weights. Clef is 27B (≈85GB VRAM) with image support; Laya is non-autoregressive and reportedly ≈33 ms per decision on commodity GPUs.	Someone has to own the GPU bill, the on-call rotation, and the license diligence — see open-weight decision models.

Five rows. Five picks. The rest of the thirteen are rational alternates — if your team already lives in Perplexity, Bedrock, Nace, or Celeris, the switching cost to the recommended pick is probably higher than the quality gap. Use what you have, verify on your own data, and keep the adapter honest.

Why am I keeping Jev as my default?

Jev is my default for new work because it is cheapest among hosted options, it defined the wire format most alternatives copy, and sitting on it keeps my provider adapter stress-tested.

Three concrete reasons, written down so the next time someone asks “why not switch everything to Clef?” I can send a link.

• Cost floor. At $0.042 per million input tokens with output free, Jev is roughly half the price of OpenAI’s Decisions API, under half of Clef, and the only hosted vendor whose published price I have seen matched by any catalog listing. For the volume I run, that is a real line item.
• Default wire format. Four other hosted vendors — Liquid AI’s d1, Nace.AI’s Drex, Celeris-1, Upstage’s Solar Decide — plus the community open-weight projects SemIF and DJev accept Jev’s /v1/systemone body wire-compatibly. Writing against Jev means writing against the format the market copies, which keeps the adapter small and the exit options plural.
• Credibility of the underlying lab. TypeSafe AI raised ~$870M and is run by one of the co-creators of ChatGPT. The hosted service has been stable through the three-week consensus and the first-month commoditization that followed. Reliability over marketing.

The honest version: I am also keeping Jev because switching costs me time, and the alternatives are not yet so clearly superior on calibration or image fidelity that I would pay that time. The month Clef’s calibration or Clef-flash’s price-performance tips, I will switch — and because the adapter is three functions, the switch is a Dockerfile ENV change. For the explicit shape of the adapter and the testing protocol around a swap, see the one-line migration.

My testing posture: dual-write, replay, decide

I treat every new vendor as a shadow until a week of production traffic says otherwise. The testing posture is the second half of the framework.

Four steps, repeatable, no data-science team required:

• Dual-write for a week. Fork every inbound decision call to both the current default and the candidate. Act on the default’s answer in production; silently log the candidate’s answer.
• Diff the outputs by request id. A nightly job joins the two logs and counts disagreements. For each disagreement, snapshot the input so a human reviewer can judge. The protocol owes a lot to the own-data test in reading decision model benchmarks.
• Measure calibration on the diffs, not the whole set. The whole set is boring — both models agree 85-95% of the time. The interesting data lives in the 5-15% where they disagree. Run the honest-confidence test on that slice.
• Decide, swap, and keep the loser warm. If the candidate wins, flip the environment variable. Keep the loser’s adapter in the codebase for the next month in case the new default drifts. For the broader placement question — where this routing lives inside an agent — see where decision models fit in an agent stack.

Dual-write is cheap when your three-function adapter already exists; expensive when it does not. If you have not written the adapter yet, that is the one-week engineering task that pays back the fastest in this category. The deeper build-your-first-experiment framing lives in your first decision model experiment.

Image placeholder

A clean, four-step horizontal timeline on an off-white background. Four pill-shaped tiles in a row, each a soft shade (pale slate, pale emerald, pale blue, pale sand), labeled from left to right: '1. DUAL-WRITE A WEEK', '2. DIFF BY REQUEST ID', '3. CALIBRATE THE DIFFS', '4. SWAP OR WAIT'. A thin emerald-green rule connects the tiles. Above the timeline, a short tagline reads 'the swap protocol: no data scientist required'. Clean, flat, geometric. Palette: off-white background, pale slate borders, one emerald accent, navy ink. Linear or Stripe editorial feel. No AI robots.

• Aspect ratio: 16:9
• Source size: 1280 × 720 px (sharp on retina at 760 px display width)
• Format: PNG
• Target file size: under 500 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

Frequently asked questions

Which decision API should I pick in late 2026?

Pick in two steps. First, apply the five-question framework — request format, image input, context length, calibration, licensing — and keep only the vendors that pass all five for your workload. Second, map the survivors to the short-picks table: Jev for lowest hosted cost, OpenAI or Microsoft for highest quality, Clef or Clef-flash for multimodal, Upstage Solar Decide for very long documents, and Cloudflare’s open Clef or ConvAI Laya for self-hosted.

Which decision API is cheapest right now?

Among hosted vendors with published prices, TypeSafe Jev at $0.042 per million input tokens is the lowest I have verified. Upstage Solar Decide is $0.05 on OpenRouter and $0.10 first-party. Cloudflare’s Clef-flash is reportedly $0.09 and the larger Clef reportedly $0.24. OpenAI’s Decisions API is $0.10. Self-hosted open-weight models carry compute cost only, which can be lower per call at high volume but higher once you include engineering time.

Which decision API accepts images?

Three product lines accept image input as of October 2026: Cloudflare’s Clef and Clef-flash (up to four images per request, Apache 2.0), OpenAI’s Decisions API (on GPT-6 Luna), and Liquid AI’s d1-omni-600M open-weight variant. Jev, Upstage Solar Decide, Microsoft Decision-1, Laya, SemIF, DJev, and AWS Strands Decider 2B all launched text-only. If your workload is receipts, screenshots, or document extraction, start the short list from the image-capable set.

Which decision API has the longest context window?

Most hosted decision models cluster between 32K and 64K tokens. Upstage Solar Decide is the outlier, with vendor-adjacent catalog listings describing a 512K-token context window — reportedly the longest of the Jev-compatible camp. Verify on your own traffic before you commit to a long-context workload, and treat the vendor’s warning that the schema may shift before GA as part of the pick.

Should I self-host a decision model?

Only if volume, data-residency, or compliance requirements justify the GPU bill, the on-call rotation, and the license diligence. The honest crossover is high — a 27B open-weight model like Cloudflare’s Clef needs roughly 85GB of VRAM, and a 9B flash variant about 41GB — so hosted still wins for most startups. The two scenarios where self-hosting pays today are high-volume text workloads on Laya or SemIF and VPC-only deployments where no hosted option is permitted.

Why do you keep Jev as your default?

Three reasons. One, it is the cheapest hosted option whose price I have verified ($0.042 per MTok input, output free). Two, four other hosted vendors and multiple open-weight community rebuilds copy its request format wire-compatibly, so writing against Jev keeps the exit options plural. Three, the underlying lab (TypeSafe AI, co-founded by one of ChatGPT’s co-creators) is well-funded and the hosted service has been stable through the first month of the category.

How do I know when to swap decision API vendors?

Run a one-week dual-write pilot behind a three-function adapter — choose, score, verify. Diff the two vendors’ outputs by request id, snapshot the disagreements, and measure calibration on the diff slice (not the whole set). If the candidate wins on cost, calibration, or latency without breaking downstream workflows, flip the environment variable. Keep the loser’s adapter warm for a month in case the new default drifts.

---

If you are picking a decision API for a Q1 pilot and the five-question framework is starting to feel like a shape only an architect can navigate, that call-site-by-call-site judgment is exactly what a Fractional CTO is paid to make. The category commoditized in a month; the mistakes that will matter are the ones made in the first ninety days. One hour of the right conversation can save a quarter of engineering time. More pieces in this thread live in the AI Strategy archive, and the broader SMB AI strategy frame sits a level up.