13 Decision APIs in 3 Weeks: A Builder's Map of the Market

Image placeholder

Editorial, product-forward hero illustration on an off-white background — a wide, calm 'market map' arrangement of about a dozen rounded rectangular logo tiles laid out in three horizontal bands. Top band labeled 'HOSTED, OWN FORMAT' holds four tiles with wordmark-style labels (OPENAI, MICROSOFT, UPSTAGE, PERPLEXITY). Middle band labeled 'HOSTED, JEV-COMPATIBLE' holds three tiles (JEV, LIQUID, CLOUDFLARE). Bottom band labeled 'OPEN-WEIGHT' holds four tiles (CLEF, LAYA, SEMIF, STRANDS). Tiles are different soft shades: pale slate, pale emerald, pale blue, pale sand — never saturated. One thin emerald-green horizontal rule runs between bands. A single short tagline sits above the map: 'thirteen decision APIs in three weeks'. 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 10, 2026.

Key takeaways

• Between September 15 and October 13, 2026, at least thirteen vendors shipped something that fits the decision API shape. That includes four majors (TypeSafe, OpenAI, Microsoft, Cloudflare) and nine smaller or open-weight entrants.
• The grammar converged almost immediately. Nearly every vendor returns a typed answer — choice, score, or probability — plus a confidence number, in a single forward pass, from a schema the caller supplies.
• I group them on three axes: request format (Jev-compatible, own-format, or structured-output add-on), image input (yes / no), and price per million input tokens where published.
• I call the pattern first-month commoditization — a new API category attracting 10+ competing implementations inside its first calendar month. The three-week consensus validated the shape; first-month commoditization erased the moat.
• Builders should treat the whole set as one commodity surface. Hide the vendor behind a thin adapter, pick on cost and privacy per workload, and expect the price curve to bend further by Q1 2027.

The short answer: In the thirty days after TypeSafe AI shipped Jev on September 15, 2026, I counted thirteen vendors who either shipped a dedicated decision API or wired decision-shaped behavior into an existing product. The majors — TypeSafe, OpenAI, Microsoft, Cloudflare — are familiar. The next tier is less familiar but real: Liquid AI, Upstage, AWS, and the open-weight projects Laya, SemIF, and DJev. The category went from zero to commoditized before most buyers noticed it existed. This is the map.

Someone pings you on Slack: “Which decision API should we use?” A fair question in September; a trick question by mid-October — the answer is now “which of these thirteen?” with another one likely to land before you finish evaluating the first three.

What are the thirteen decision APIs I counted in the first month?

Thirteen vendors shipped something decision-shaped between September 15 and October 13, 2026. Here is the list, with confidence levels marked honestly.

• TypeSafe AI — Jev (Sep 15, 2026). The vendor that opened the category. Launch coverage.
• ConvAI Innovations — Laya (~Sep 18, 2026). Apache 2.0 open-weight, non-autoregressive, ~33 ms per decision.
• Liquid AI — d1 (hosted) and d1-3B / d1-omni-600M (open-weight) (late Sep–Oct 7, 2026). Served through Liquid’s API and Vercel’s AI Gateway.
• Upstage — Solar Decide (~Sep 28, 2026). Hosted, text-only, listed on OpenRouter.
• OpenAI — Decisions API (Sep 29 preview; Oct 6 public beta). GPT-6 Luna, accepts images. ProPakistani coverage.
• Cloudflare — Clef and Clef-flash (Oct 1, 2026). Open-weight under Apache 2.0, 27B and 9B parameters, four images per request, 64K context. Flavio Copes deep-dive.
• AWS — Strands Decider 2B (reportedly Oct 1, 2026, open-source). Reported by implicator.ai.
• SemIF (ex-OpenJev) — MIT community project; reads option probabilities from open models.
• DJev — community rebuild in the same shape as SemIF.
• Microsoft — Decision-1 (Oct 9, 2026) in Azure AI Foundry; 32,768 context, calibrated probability scores. Foundry announcement.
• Perplexity Structured Outputs (sonar). Adjacent — JSON Schema path that fits the typed-answer shape.
• Amazon Bedrock Structured Outputs. Adjacent — GA since Feb 2026, usable as a decision surface via enum fields.
• Mistral Classifier Factory. Adjacent — a text-classification endpoint solving the same job.

That is thirteen entries. The honest version: seven are unambiguously decision APIs, two are open-weight equivalents, two are community rebuilds, and two are general-purpose structured outputs that fit the shape. For the deeper read on just the big three majors, see OpenAI, Microsoft and Cloudflare joined in.

How did I group them? Three axes that actually matter

I ignored “who runs the cloud” and grouped on three axes a builder cares about: request format, image input, and price.

• Request format. Does the vendor expose its own endpoint, copy Jev’s Choice / Score / Noul shape, or ride a general-purpose structured-output API? This sets your switching cost later.
• Image input. Can the model see pictures, or is it text-only? Image-capable models unlock document, receipt, and visual-moderation workflows that text-only models cannot touch.
• Price per million input tokens. For high-volume paths — email triage, moderation, lead scoring — this is the number that compounds into real operating cost.

Two other axes mattered less than I expected: context window (most cluster between 32K and 64K) and latency (vendor-reported, so comparing is a trap). They appear in the table below but should not decide the pick.

Axis one: request format splits the market into three camps

Request format is the single most load-bearing choice. It decides whether swapping vendors next quarter costs one file or one sprint.

• Jev-compatible endpoint. Liquid AI’s d1 family and Cloudflare’s Clef family both expose a Jev-shaped request, so existing Jev integrations switch by changing model id and base URL. That is the clearest convergence signal and the easiest migration to pilot.
• Own endpoint and schema. OpenAI’s /v1/decisions (Choices / Scores / Predicates), Microsoft’s Decision-1, Upstage’s Solar Decide, and TypeSafe’s Jev endpoint all exist as first-class, named products. They solve the same job; the wire format is theirs.
• Structured output as a decision surface. Perplexity’s response_format on sonar, Bedrock’s JSON Schema outputs, and Mistral’s Classifier Factory are not framed as decision products, but a schema with an enum field and a confidence field returns the same typed answer. The ceiling is lower (no native calibrated probability), but the shape fits.

If your team already lives inside one of these ecosystems, the structured-output path is usually the fastest way to prove the pattern before shopping the market. The reasoning behind that build-cheap-first approach lives in your first decision model experiment.

Axis two: image input splits the market down the middle

Six of the thirteen entries accept image input; the rest are text-only. This axis decides which workflows you can touch at all.

• Image-capable: Cloudflare’s Clef and Clef-flash (up to four images per request), OpenAI’s Decisions API, and Liquid AI’s d1-omni-600M variant.
• Text-only at launch: TypeSafe’s Jev, Upstage’s Solar Decide, ConvAI’s Laya, SemIF, DJev, and AWS Strands Decider 2B all shipped text-first.
• Depends on the base model: Perplexity sonar, Bedrock, and Mistral inherit whatever modality their base models support.

If your workload is document extraction, invoice tagging, visual moderation, or receipt-based decisions, the image-capable set is the only honest short list.

Axis three: published price per million input tokens

Where published, prices cluster between $0.042 and $0.24 per million input tokens, with output tokens generally free.

• TypeSafe Jev: $0.042 input; output free.
• Upstage Solar Decide: $0.05 input; output free (OpenRouter).
• Cloudflare Clef-flash: reportedly $0.09; Clef (larger) reportedly $0.24.
• OpenAI Decisions API: $0.10 input; output and cache free.
• Microsoft Decision-1, Liquid d1 (hosted): not clearly published at time of writing.
• Open-weight (Laya, Clef, Strands Decider, d1-3B, SemIF): self-host cost only, often zero marginal per-call price once loaded.

Inside a month, hosted prices went from one data point ($0.042) to a spread between $0.042 and $0.24, with open-weight models dragging the floor toward “compute cost only.” For high-volume paths, the hosted spread is small; the gap to self-hosted Laya is enormous. For the full build-vs-buy framing, see open-weight decision models.

Image placeholder

A clean, horizontal price-ladder infographic. A single thin emerald rule runs across the midline. Six to eight small vendor labels sit at their price points along the rule: 'Self-hosted (Laya, Strands, SemIF) — $0', 'Jev — $0.042', 'Solar Decide — $0.05', 'Clef-flash — $0.09', 'OpenAI Decisions — $0.10', 'Clef — $0.24'. A short caption below the rule reads 'Hosted per-million-token prices, as of October 2026 — vendor-reported where open figures exist'. Palette: off-white background, pale slate ticks, emerald rule, navy ink labels. Clean, flat, product-forward. 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 vendor table: everything on one page

Here is the whole set in one grid, with “n/a” wherever I could not verify a number. Use it to prune your short list, not to pick a winner.

Vendor / Model	Launch	Request format	Image input	Price per MTok (input)
TypeSafe Jev	Sep 15, 2026	Choice / Score / Noul	No (text-only)	$0.042
ConvAI Laya	~Sep 18, 2026	Typed decisions (open)	No	self-host
Liquid AI d1 (hosted)	late Sep–Oct 2026	Jev-compatible	No (base)	n/a
Upstage Solar Decide	~Sep 28, 2026	Own (System One)	No	$0.05
OpenAI Decisions API	Sep 29 / Oct 6, 2026	Choices / Scores / Predicates	Yes	$0.10
Cloudflare Clef	Oct 1, 2026	Jev-compatible	Yes (up to 4)	reportedly $0.24
Cloudflare Clef-flash	Oct 1, 2026	Jev-compatible	Yes (up to 4)	reportedly $0.09
AWS Strands Decider 2B	reportedly Oct 1, 2026	Open-source	No	self-host
SemIF (ex-OpenJev)	Sep 2026 (community)	Own open shape	No	self-host
DJev	Sep–Oct 2026 (community)	Own open shape	No	self-host
Microsoft Decision-1	Oct 9, 2026	Fixed-option probability	Not emphasized	n/a
Liquid d1-3B / d1-omni-600M	Oct 7, 2026	Open-weight	d1-omni: yes	self-host
Perplexity Structured Outputs (sonar)	adjacent	JSON Schema / regex	Base model	sonar pricing

Three caveats. “Reportedly” numbers stay reportedly, and prices change weekly in commoditizing markets. Some rows are community projects, not commercial products — a distinction that matters for procurement even when the API shape is identical. By the time you read this, there will likely be two more entrants and one acquisition. The deep-dive on which of these are Jev-wire-compatible in detail lives in Jev-compatible decision APIs.

Why did this category commoditize so fast?

Because the shape of the API is small and the economic payoff of being in it is large. Three forces compressed a multi-year arc into a single month.

• Small primitives, obvious grammar. Every decision workload decomposes into pick-one / rate-on-scale / verify-probability. Any lab with a frontier model already built those patterns internally; packaging them is weeks of API work, not months of training. For the taxonomy, see the three questions a decision model answers.
• Shared infrastructure, shared training data. Many of these models fine-tune from the same base checkpoints (ModernBERT, Qwen, Llama, GPT-6 derivatives). The ceiling is set upstream, so downstream products converge in quality faster than they converge in branding.
• Enterprise buyers asked the same question in parallel. Once Jev named the category, every procurement conversation at every cloud vendor’s enterprise team changed in the same week. Shipping fast was the cheapest way not to lose a renewal.

I call the resulting pattern first-month commoditization: when a new API category attracts ten or more credible competing implementations inside its first calendar month. First-month commoditization is a stronger signal than the three-week consensus I described in OpenAI, Microsoft and Cloudflare joined in. The three-week consensus says the majors validated the shape. First-month commoditization says the market has already decided no one owns it. If you are a startup selling into this surface, that is the bad news. If you are a builder consuming it, that is the headline good news of the quarter.

The commoditization also means moats need a new location. The primitives are shared now; the surviving moats are calibration quality, domain-specific fine-tuning, image fidelity, latency floors, data residency, and ecosystem integration. Vendors who defend the shape itself will lose; vendors who defend one of those cells will keep pricing power. For the calibration side, see the calibration feature nobody talks about.

What should buyers actually do with a thirteen-vendor map?

Pick on cost, image needs, and privacy per workload; hide the vendor behind a thin adapter; expect to switch at least once in the next year. Three concrete moves.

• Pilot on whatever you already have. If you already pay OpenAI or Azure, start there — integration friction is lower than any benchmark gap you will measure. If you are an Astro-on-Cloudflare shop, Clef-flash is on the hot path for your worker already.
• Write a one-file adapter. Three functions — choose, score, verify — behind which every vendor on the list fits. Every current vendor can be shimmed in a day. The thin-adapter pattern is detailed in choosing a decision API in 2026 and the broader framing in how I use decision model in my product.
• Budget for a swap. Price curves bend; entrants arrive; calibration improves unevenly. If your contract assumes “we pick a decision vendor forever,” you have mispriced the risk. For the question of whether you need a developer to run the pilot, see do you need to be a developer to use a decision API?.

The one thing not to do is treat “thirteen vendors” as a reason to freeze. Paralysis is cheaper than a wrong pick in a stable market and more expensive than it in a commoditizing one. This is the second kind.

Frequently asked questions

How many decision APIs launched in the first month after Jev?

I counted thirteen between September 15 and October 13, 2026 — four majors (TypeSafe, OpenAI, Microsoft, Cloudflare), smaller hosted entrants (Liquid AI, Upstage), adjacent structured-output products (Perplexity, Mistral, Bedrock), and open-weight or community entrants (Laya, SemIF, DJev, AWS Strands Decider 2B, Clef, Liquid’s d1-3B / omni-600M). Seven are unambiguously decision-shaped products; the rest fit the shape via structured output or community-rebuilt open models.

Which decision APIs accept image input?

As of October 2026, Cloudflare’s Clef and Clef-flash accept up to four images per request, OpenAI’s Decisions API accepts images on GPT-6 Luna, and Liquid AI’s d1-omni-600M includes image handling. Jev, Upstage’s Solar Decide, Microsoft’s Decision-1, ConvAI’s Laya, SemIF, and AWS Strands Decider 2B all launched text-only. If your workflow is document extraction, visual moderation, or receipt-based tagging, the image-capable set is your short list.

What is first-month commoditization?

A market signal I named for this piece: when a new API category attracts ten or more credible competing implementations inside its first calendar month, that category is already commoditized. The shape is now shared infrastructure. Moats migrate from the primitives themselves (which no one owns) to calibration, latency floors, data residency, image fidelity, and ecosystem integration. Decision APIs cleared this bar in roughly 28 days.

Are all thirteen decision APIs actually the same product?

Not quite, but the grammar is nearly identical. Every verified vendor returns a typed answer (choice, score, or probability) plus a confidence or calibrated probability in a single forward pass against a schema the caller supplies. Differences live in request format (Jev-compatible vs own vs structured-output), image support, context window (32K to 64K is normal), and price per million tokens. See the in-article table for the per-vendor breakdown.

Which of the thirteen is cheapest right now?

Among hosted options with published prices, Jev at $0.042 per million input tokens is the lowest. Upstage Solar Decide follows at $0.05. Cloudflare’s Clef-flash is reportedly $0.09, OpenAI’s Decisions API is $0.10, and the larger Clef is reportedly $0.24. Open-weight models (Laya, AWS Strands Decider 2B, Clef, d1-3B, SemIF) carry only your compute cost once loaded. Prices will change; verify before you commit.

Should I pick my decision API vendor based on this map?

For a pilot, yes. For the long run, no — pick on fit per workload, hide the vendor behind a thin adapter with choose / score / verify functions, and let operational data (accuracy, latency, calibration drift, cost per call) choose your long-term vendor over the next six to twelve months. Treat decision APIs the way you treat object storage: important, commodity, swappable.

Is this the final list of decision APIs?

Definitely not. The list reflects what I could verify by October 13, 2026. I expect at least two more entrants before year end — plausible releases from Anthropic, Google, and one or more frontier startups, plus more open-weight rebuilds on Hugging Face. Treat the thirteen as a floor, not a ceiling, and re-check before signing any twelve-month commitment.

---

If you are picking a decision API for a Q4 pilot and the thirteen-vendor map 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.