DEV Community: Paul Lovelace

Decision Models Are in a Price War: $0.10 vs $0.04 vs $0.02

Paul Lovelace — Tue, 13 Oct 2026 09:33:47 +0000

Three companies launched decision-model APIs in nine days. OpenAI charges $0.10 per million input tokens. Perplexity charges $0.02. Microsoft sits in the middle at $0.042. All three return probabilities instead of prose, all three bill $0 for output — and Perplexity's weights are open source. Here's the full scoreboard, what the benchmarks actually say, and which one to prototype with.

What a decision model is (30 seconds)

A decision model doesn't write text. You send it a state (text, JSON, images) plus one or more typed questions, and it returns structured answers: a yes/no probability, a choice from your list with confidence, or an ordered score. The category got its name from TypeSafe's Jev, launched September 2026. Since October 1, it's been launch week every week.

The scoreboard

Model	Launched	Input price	Output price	Weights	Context
OpenAI Decisions API (gpt-6-luna)	Oct 6	$0.10 / 1M	$0	Closed	undisclosed
Perplexity pplx-decider-v1-27b	Oct 1	$0.04 / 1M	$0	Apache 2.0	262k
Perplexity pplx-decider-v1.1-27b	Oct 7	$0.02 / 1M	$0	Apache 2.0	262k
Microsoft-Decision-1	Oct 9	$0.042 / 1M	$0	undisclosed	undisclosed
TypeSafe Jev	Sep 2026	varies	varies	—	—
Cloudflare Clef / Clef-flash	Oct 1	undisclosed	undisclosed	open	—
AWS Strands Decider 2B	Oct 1	undisclosed	undisclosed	—	—

Seven launches in about five weeks. The pricing spread is 5x from cheapest to most expensive — for APIs that do structurally the same thing.

Why is Perplexity so much cheaper?

Two reasons, both verifiable. First, the model is small: 27B parameters, fine-tuned from Qwen3.8-27B, versus whatever frontier-scale model sits behind OpenAI's endpoint. Smaller model, cheaper inference — the math is straightforward.

Second, Perplexity open-sourced the weights under Apache 2.0. You can self-host v1.1 if you have a GPU with roughly 49 GiB of VRAM. That puts a ceiling on what they can charge: anyone with hardware can run it for the cost of electricity. OpenAI's closed model has no such ceiling.

The honest caveat: cheaper per token is not cheaper per correct decision. A $0.02 model that's wrong 15% of the time costs more than a $0.10 model that's wrong 5% of the time — once you price in the cost of being wrong.

What do the benchmarks actually say?

Perplexity's own numbers put pplx-decider-v1 at 85.71% versus Jev's 84.51% across an 11-benchmark, 7,210-sample panel, with the widest gap on RAGTruth (88.80% vs 77.27%). Jev still leads on 4 of the 11 tests, including WinoGrande and BBH.

Treat every number in that paragraph as a company claim. Perplexity's docs publish no benchmark table — the figures come from their announcement, not an independent rerun. The community Decision Index leaderboard (a Hugging Face project tracking open Jev reproductions) shows Perplexity at 62.75 vs Jev at 60.11 under its v0.3 scoring — but the formula changed between editions, so even those two numbers aren't directly comparable.

An independent evaluation by SAS (about 50 examples per dataset, three runs each) measured v1 at 0.95 accuracy on hand-written cases but 0.80 on public datasets, with calibration error 0.06–0.09 and median latency around 0.3s. Small sample, but it's the closest thing to a third-party number available.

Bottom line: Perplexity's model looks competitive with Jev on Perplexity's tests. Nobody has published a head-to-head of all seven against each other. The benchmark war is marketing until independents run the same suite on every model.

How fast are they?

Perplexity publishes latency figures from its own tests (September 30): under 2 seconds for a few hundred input tokens, ~5s at 90k tokens, ~14s at 190k, ~23s just under the 262k input ceiling. OpenAI publishes a "10x faster than the Responses API" claim with no benchmark attached. Microsoft and the others publish nothing.

Latency scales with input length on every one of these — a decision over a 200k-token document is a different beast than a decision over a tweet. Test on your actual input sizes.

Which one should you prototype with?

If you want cheapest right now: Perplexity v1.1 at $0.02/M. Half the price of v1, open weights as a fallback, no per-request fee.

If you want open weights: Perplexity, full stop. It's the only decision model in the table you can self-host today.

If you're already on OpenAI infra: the Decisions API keeps you in one billing account and one SDK. You're paying 5x the per-token rate for that convenience — fine at prototype scale, worth re-examining at volume.

If you need a second opinion on accuracy: run the same 200 labeled examples through two of them and compute a confusion matrix before committing.

The pattern underneath

This is the same unbundling I wrote about earlier: the industry spent years selling one primitive (generate text) and developers built classifiers out of prose plus parsing. Now classification is its own product category with its own price war — seven entrants in five weeks, prices already down 5x from top to bottom.

Expect the same thing to happen to every other "LLM wearing a costume" workload. Reranking, extraction, and moderation are next.

TL;DR

7 decision-model launches in ~5 weeks: OpenAI ($0.10), Perplexity v1 ($0.04) and v1.1 ($0.02), Microsoft ($0.042), plus Jev, Cloudflare Clef, AWS Strands Decider
Perplexity is cheapest AND open-weight (Apache 2.0, self-hostable at ~49 GiB VRAM)
All benchmarks cited are company-provided; no independent head-to-head exists yet
Prototype on the cheapest, validate accuracy on your own labeled data, then decide

Sources: Perplexity docs and timeline (Oct 1–7, 2026), OpenAI Decisions guide, tsnmedia.org comparison (Oct 2026), explainx.ai decision-models guide, AI Weekly alert, SAS Model Card evaluation, OpenRouter pricing pages. Benchmark figures are vendor-provided unless noted; no independent cross-model benchmark was available at writing time.

OpenAI's Decisions API: Stop Paying for Words You Don't Read

Paul Lovelace — Tue, 13 Oct 2026 08:59:48 +0000

Here's a pricing model I didn't expect to see: an LLM API that charges you $0 for output tokens.

OpenAI's Decisions API entered public beta on October 6, 2026. It doesn't generate text. It returns decisions — a probability, a choice, or a score — and bills you only for what you send in. Here's what it actually does, where the math works, and where OpenAI's claims need a second look.

What it is

A dedicated endpoint — POST /v1/decisions — that turns text or images into a machine-usable answer. You define the question; the API returns one of three typed shapes:

Predicate: a 0-to-1 probability that a condition is true ("is this message urgent?")
Choice: one option picked from your fixed list, with confidence scoring ("route to: billing / support / shipping / account")
Score: a rating against ordered severity levels

No prose to parse. No "this appears to be a billing-related issue, so I recommend..." paragraph that your code then has to regex into an action. The answer arrives already structured.

It runs on gpt-6-luna — currently the only supported model. Inputs can be text, images, or both, though images must be inline base64 data URLs (up to 128 per request); hosted links and uploaded file IDs are refused.

The pricing: input-only billing

This is the part worth doing math on:

$0.10 per 1M input tokens
$0 output tokens. $0 cache reads. $0 cache writes.

Compare with calling gpt-6-luna through the normal endpoints: $0.10 input / $0.50 output. For classification-style workloads — where the answer is a label, not an essay — the output bill was always the insult added to injury. Decisions API removes it entirely.

One analysis put it at roughly one-fifth the cost of standard Luna pricing for classification workloads with short answers. Your mileage depends on your input/output ratio, but the direction is unambiguous: if your LLM calls return three tokens of verdict, you were overpaying.

Two asterisks, both from OpenAI's own docs: regional processing premiums and long-context input multipliers apply, with no published figures. Price it on your actual traffic, not the headline.

The 10x speed claim — handle with care

OpenAI says Decisions returns answers "about 10x faster than the Responses API." That number appears in the launch materials with no accompanying benchmark, no per-call compute disclosure, and no head-to-head accuracy comparison between /v1/decisions and the same gpt-6-luna model called through the Responses API.

Faster is plausible — skipping autoregressive text generation for a typed scalar should be cheaper compute. But "10x faster at what accuracy?" is unanswered. A decision API that returns the wrong choice quickly is worse than a slow one that's right. OpenAI's own guidance says to set thresholds from your labeled examples, which is the honest version of "validate this yourself."

Treat the 10x as marketing until someone publishes numbers. The pricing, at least, is verifiable arithmetic.

Decisions vs Structured Outputs vs function calling

OpenAI's own guide draws the lines:

Decisions API: you need a verdict — classify, route, score, gate. The answer IS the output.
Structured Outputs (Responses API): you need extracted fields or a written explanation alongside structure.
Function calling: you need the model to trigger a tool with arguments.

If you find yourself prompting "respond with ONLY the word billing" and then stripping whitespace and lowercasing — that's a Decisions API call wearing a Chat Completions costume. Migrate it.

Where it fits

Good fit:

Content moderation and triage queues (classify → route → act)
Agent tool-routing: "which tool handles this request?" as a typed choice
Any pipeline where an LLM currently returns a label you parse
Compliance-sensitive flows — it ships with Zero Data Retention support, HIPAA eligibility, and US/EU data residency, which makes it a plausible drop-in for gating flows that previously stitched JSON-schema prompts onto Chat Completions

Watch out:

Beta status — GA is "coming weeks," no firm date
Single model (gpt-6-luna) — no fallback if Luna misbehaves on your domain
Image inputs are inline-only — if your pipeline serves hosted URLs, you add a fetch-and-encode step
Undisclosed regional/long-context multipliers — model your costs on measured traffic

The bigger pattern

Decisions API is OpenAI unbundling the LLM. For years the industry sold one primitive — "generate text" — and developers built classifiers, routers, and scorers out of prose plus parsing. Now the primitives are splitting: text generation for what needs text, typed decisions for what needs decisions, each priced on what it actually costs to serve.

Anthropic did the same split from the other direction this month: Haiku 5.5 for volume, Opus 5.5 for frontier reasoning. The era of one-model-fits-all is ending. The winners will be the teams that route each call to the cheapest primitive that can do the job.

TL;DR

Decisions API (public beta, Oct 6): POST /v1/decisions, returns probability / choice / score instead of prose
Pricing: $0.10/1M input, $0 output — roughly 5x cheaper than standard Luna for classification workloads
10x-faster claim is unverified — validate accuracy on your own labeled data
Use it when the answer is a verdict; keep Structured Outputs when you need explanation + structure
Beta caveats: single model, inline images only, undisclosed regional multipliers

Sources: OpenAI developer forum announcement (Oct 6, 2026), OpenAI Decisions guide and pricing page, AI Weekly, FourWeekMBA, Ground Truth. Speed and accuracy claims are OpenAI's; no independent benchmark was available at writing time.

Claude Haiku 5.5: The $0.10 Model That Makes Meta's $4 Look Expensive

Paul Lovelace — Tue, 13 Oct 2026 07:14:26 +0000

Meta just charged $4 per million tokens for Muse Wonder. Five days earlier, Anthropic launched Claude Haiku 5.5 at $0.10 per million.

Same week. 40x price difference. Here's what Haiku 5.5 actually gives you — and where the cheap price hides real trade-offs.

What launched (Oct 7, 2026)

Claude Haiku 5.5 — Anthropic's smallest, fastest, cheapest model. Third release in the Claude 5.5 family, ahead of their planned IPO.

The headline numbers:

$0.10 / $0.50 per million input/output tokens (prompts under 100K tokens)
$0.50 / $2.50 for longer prompts — watch this, it matters
1M token context window (up from 200K on Haiku 4.5)
128K max output (up from 64K)
Model ID: claude-haiku-5-5

Anthropic says it's 75% cheaper than Haiku 4.5 and calls it the fastest, most efficient member of the family.

What's actually new (not just cheaper)

Adaptive thinking. Haiku 5.5 decides how much reasoning a task needs — on by default. First Haiku with adjustable effort controls, so you can trade intelligence against cost and latency yourself.

1M context. This is the big one for a "small" model. A million tokens of context at $0.10/1M means you can stuff entire codebases, long documents, or massive conversation histories into the cheap tier.

Built for volume. Anthropic is pitching it as the workhorse: classification, summarization, extraction, live support, voice agents, in-app assistants — plus a fast subagent model for its bigger Opus and Sonnet siblings.

The pricing trap nobody mentions

Read the rate card twice:

Under 100K tokens: $0.10 / $0.50
Over 100K tokens: $0.50 / $2.50 — that's 5x on input

So the "$0.10 model" is only $0.10 if you stay under 100K tokens per prompt. The moment you actually use that 1M context window — the headline feature — you're paying 5x more per input token. The cheap price and the big context are in tension by design.

This isn't dishonest, it's just how tiered pricing works. But every "Haiku 5.5 costs $0.10" headline you've seen is missing the asterisk.

Where it fits (and where it doesn't)

Use it for:

High-volume classification, extraction, summarization
Subagent calls inside bigger workflows (cheap reasoning steps)
Voice agents and live support where latency matters
Anything where you'd currently use Haiku 4.5 — it's strictly better and 75% cheaper

Don't use it for:

Frontier reasoning — that's Opus 5.5's job at 40x the price
Long-context work without doing the math — over 100K tokens, compare against Sonnet 5.5's halved cache-read pricing (Anthropic cut those the same day, making agentic work ~20% cheaper)
Anything needing the strongest safeguards — note Haiku 5.5 ships with built-in blocks on a narrow set of high-risk cybersecurity requests

The real story: the market is splitting in two

Muse Wonder at $4/$20 and Haiku 5.5 at $0.10/$0.50 launched five days apart. That's not a coincidence — it's the market bifurcating:

Premium tier ($4+/1M): frontier reasoning, memory, marathon coding — Wonder, Opus 5.5
Volume tier ($0.10/1M): fast, cheap, good-enough — Haiku 5.5

The smart architecture isn't picking one. It's routing: Haiku 5.5 for the 90% of calls that don't need frontier intelligence, Opus/Wonder for the 10% that do. Anthropic basically told you this by pitching Haiku as a subagent model.

TL;DR

Claude Haiku 5.5: $0.10/$0.50 per 1M (under 100K tokens), 1M context, adaptive thinking
The $0.10 price jumps 5x past 100K tokens — do the math before stuffing context
75% cheaper than Haiku 4.5, available on API, Bedrock, Google Cloud, Copilot
Real play: route volume work to Haiku, frontier work to Opus/Wonder

Sources: Anthropic announcement (Oct 7, 2026), Reuters, Claude Platform docs. Pricing from Anthropic's published rate card.

Muse Wonder API: 5 Gotchas Before You Switch from Claude

Paul Lovelace — Tue, 13 Oct 2026 05:44:48 +0000

Everyone's comparing benchmark scores. Here's what the model card and independent measurements say you should plan for before wiring it into production — five gotchas.

1. The best model isn't on the API

Meta launched two models: Muse Wonder and Muse Wonder Full. Only Wonder is on the API (muse-wonder-1.0).

Wonder Full — the one that actually beats competitors on benchmarks — is subscription-only through paid Muse Code plans. If you're architecting around the benchmark numbers you saw in headlines, check which model they belong to. Most of the impressive ones are Full.

2. Meta's cheap era is officially over

Wonder costs $4/1M input, $20/1M output — identical to Claude Opus 5.5, cent for cent. Cached input is $0.20/1M on both.

If you picked Meta historically for price, recalibrate. The decision is now purely about capability fit, not cost advantage.

3. Design for cached input or bleed money

At $0.20/1M, cached input is 100x cheaper than fresh input. With a 1M-token context window, the winning architecture is obvious: keep your system prompts, docs, and conversation history in cache.

Anyone porting an Opus pipeline over can keep the same caching strategy — the pricing structure mirrors Anthropic's deliberately.

4. Time to first token is brutal

Artificial Analysis measured Wonder's time-to-first-token at 19.27 seconds vs a 5.52-second median for comparable models. Throughput after that is fine (~83 tokens/sec), but if you're building anything interactive — chat, agents with user-facing steps — that first-token latency will define your UX.

This is a batch/async workload model wearing an API costume. Plan accordingly: streaming UX, optimistic UI, or background jobs.

5. Web search costs extra — and adds up

API web search is billed at $2.50 per 1,000 queries, on top of tokens. If your agent searches heavily (research agents, shopping assistants), model that cost separately. At high search volume it can exceed the token bill.

Bonus: know the knowledge gap

On general-knowledge evals, Wonder scores notably below Opus 5.5 and GPT-6 Astra — but with a low hallucination rate. Translation: it says "I don't know" instead of inventing answers. For RAG pipelines where the context carries the facts, that's actually a feature. For open-domain Q&A without retrieval, it's a liability.

TL;DR: Same price as Opus 5.5, best version not on API, ~19s first-token latency, cache aggressively, budget web search separately.

Sources: Meta model card, TechCrunch, Artificial Analysis, VentureBeat. Prices as of Oct 13, 2026.