Decision Models Explained: OpenAI Decisions API vs AWS Strands Decider vs Ollama

Write your decision logic against TypeSafe's System One schema, prototype it on Ollama or AWS's open Strands Decider for nothing but local compute, and pay for OpenAI's Decisions API only if you need image inputs or HIPAA-eligible hosting on a stack you already run. That's our pick after comparing six options that reached developers in the four weeks after TypeSafe released Jev on September 15. The schema matters more than any single model this month, because System One code moves between vendors by changing a base URL and OpenAI's does not.

A decision model takes some context, a question, and a fixed list of allowed answers, then returns one of those answers with a probability attached. It never writes a sentence. OpenAI's version bills $0.10 per 1M input tokens with no charge for output, and the whole category is pitched at the yes/no and pick-one calls an agent makes between steps. Today most teams pay for a full chat completion to answer those, then parse the prose.

We covered the individual launches as they landed (AWS Strands Decider, OpenAI's Decisions API, TypeSafe's Series A, Microsoft-Decision-1). This guide puts the field side by side and tells you which one to wire in.

What a decision model returns, and what it refuses to do

Every vendor uses the same three question types under different names. A yes/no question returns the probability that a condition is true (TypeSafe and Ollama call it noul, OpenAI calls it predicate). A choice question picks one label from a set you supply. A score question places the input on an ordered scale, such as severity, and returns a probability-weighted position that can land between levels, per OpenAI's Decisions guide. You can batch several unrelated questions against one piece of context in a single request.

Mechanically, most open implementations take a pretrained LLM, delete the head that generates tokens, and bolt on a small scoring head. AWS describes exactly that for Strands Decider: a Qwen3.5-2B "torso," a pointer head of just over a million parameters that scores each option, and a rank-16 LoRA adapter on the backbone, per the Strands Labs announcement. Because the answer space is closed, the model can't invent an option you didn't offer. It can still pick the wrong one.

AWS is blunt about the trade in that same post: the approach "makes it significantly worse at solving complex problems than reasoning models," and the lack of text output rules it out for coding, chatbots, and summarization. So a decision model sits beside your LLM. The LLM plans, writes, and calls tools; the decision model answers the small gating questions in between.

OpenAI draws the boundary against its own older features in the Decisions docs. Use Structured Outputs when you need the model to generate an object in your own JSON schema, such as extracted fields or a written explanation. Use function calling when the model needs to request a tool call with arguments. Use Decisions when the answer is a probability, a choice from a fixed set, or a score. If your answer fits one of those three shapes, the category is for you; if it needs prose, it isn't.

Six decision models side by side, as of October 12, 2026

Prices are per 1M input tokens; every option below charges nothing for output. Latency figures are each vendor's own numbers on its own hardware and workloads, so read them as claims, not a shared benchmark.

Model	Maker	Where it runs	Interface	Input price	Vendor latency claim	Source
Jev 1.13	TypeSafe AI	Hosted (TypeSafe, OpenRouter, Venice)	System One, native /v1/systemone	$0.042 on OpenRouter	70 to 500 ms on TypeSafe's internal workflows	The New Stack, Blog du Moderateur
Decisions API (gpt-6-luna)	OpenAI	Hosted only, public beta since Oct 6	Own schema, POST /v1/decisions	$0.10	About 150 ms vs about 1.6 s for a standard Luna call	OpenAI docs, OpenAI changelog, The New Stack
Strands Decider 2B	AWS Strands Labs	Self-hosted, Apache 2.0 weights plus training data and scripts	System One	Free weights, your hardware	Median about 115 ms on an RTX 3090, about 153 ms for small tasks on an M3 MacBook	Strands Labs, The New Stack
Ollama 0.35 with nimble or tev1	Ollama, models from Bespoke Labs and Together AI	Local	System One, /v1/systemone	No API charge	Nimble 9B averaged 91 ms per decision on an M5 Max	Ollama blog
Solar Decide	Upstage	Hosted (Upstage, OpenRouter)	System One	Not in launch coverage	None published	The New Stack
Microsoft-Decision-1	Microsoft	Hosted (Microsoft Foundry, OpenRouter)	Structured API call	$0.042	P50 about 35x faster than GPT-6 Sol on Microsoft's own run	Microsoft

Two more entrants sit just outside the table. Perplexity's pplx-decider ships Apache 2.0 weights and a hosted API at $0.02 per 1M input tokens on its own Decisions path, and Cloudflare's Clef and Clef-flash ship as open weights plus a hosted Workers AI option with image input, per The New Stack's October 9 market map and its October 7 roundup.

The schema split decides your switching cost

Ignore the model names for a minute, because the choice that will cost you engineering time later is the wire format.

TypeSafe defined a request shape for Jev, and it spread fast. Upstage serves Solar Decide through it, Ollama added a /v1/systemone endpoint in version 0.35 "explicitly based on TypeSafe's API," and Strands Decider answers at the same path when you run it as a server, per The New Stack. TypeSafe's own SDK works against any of those once you change the base URL. Ollama's launch post shows exactly that setup, pointing TYPESAFE_BASE_URL at http://localhost:11434 (Ollama).

OpenAI kept the semantics and changed the contract. We put the two request formats next to each other from the published docs, and the differences are small but total: none of the field names line up.

Concept	System One (TypeSafe, Ollama, Strands, Upstage)	OpenAI Decisions API
Endpoint	/v1/systemone	POST /v1/decisions
Shared context	state (string or object)	input (string, or messages with text and images)
Question list	questions object, keyed by name	questions array, each item carries a name
Yes/no type	noul	predicate
Choice options	criteria map of label to description	choices array of value and description
Score levels	criteria array of level labels	levels array of label and description
Answers	answers object keyed by question name	answers array, name echoed back
Source	Ollama blog	OpenAI docs

Here is the same "which team gets this ticket" question in both shapes, trimmed from each vendor's documented examples.

System One, sent to Ollama 0.35 at http://localhost:11434/v1/systemone:

{
  "model": "nimble",
  "state": { "ticket": "I was charged twice. Please refund the extra payment." },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this ticket?",
      "criteria": { "billing": "Payments and refunds", "technical": "Bugs and integrations" }
    }
  }
}

OpenAI, sent to https://api.openai.com/v1/decisions:

{
  "model": "gpt-6-luna",
  "input": "I was charged twice. Please refund the extra payment.",
  "questions": [{
    "type": "choice",
    "name": "team",
    "instructions": "Which team should handle this ticket?",
    "choices": [
      { "value": "billing", "description": "Payments and refunds" },
      { "value": "technical", "description": "Bugs and integrations" }
    ]
  }]
}

A thin adapter covers that mapping in an afternoon. The point is that you'll have to write it, and the rest of the ecosystem won't. The New Stack put the state of play this way on October 9: "TypeSafe is winning the schema war while the endpoint war remains open." Its writer also flags the limit of that portability. Servers still differ in option limits, in how they compute confidence, and in answer quality, so a URL swap still needs a test pass (The New Stack).

What a million decisions costs at list price

Token counts drive the bill, so we anchored on a real request. Ollama's documented three-question ticket example (one choice, one yes/no, one score) reports 841 input tokens and 4 output tokens in its response, per Ollama's launch post. Multiply that by one million requests and you're at 841M input tokens. At each vendor's published input rate:

Option	Input price per 1M tokens	1M requests at 841 tokens	Source
OpenAI Decisions API	$0.10	About $84	OpenAI docs
Jev on OpenRouter	$0.042	About $35	The New Stack
Microsoft-Decision-1	$0.042	About $35	Microsoft
Perplexity pplx-decider (hosted)	$0.02	About $17	The New Stack
Strands Decider or Ollama, self-hosted	$0 per token	Your GPU or laptop time	Strands Labs, Ollama

Treat those as rough, not exact. Each vendor's tokenizer counts the same prompt differently, and OpenAI notes that "regional processing premiums and long-context input pricing multipliers apply" on top of the base rate (OpenAI docs). The useful takeaway is the order of magnitude. Even OpenAI's rate, the highest published rate in this table, lands a million gating calls in double-digit dollars, which is why the price gap between vendors matters less than the schema gap for most teams.

Pick by what you're building

If you are...	Pick	Why	Where it flips	Source
Prototyping an agent gate and want to read the weights	Strands Decider 2B or Ollama 0.35	Open weights, local, System One wire format, no per-call bill	You need a managed endpoint in production; AWS hasn't announced a hosted option	The New Stack
Already all-in on OpenAI with ZDR or HIPAA requirements	OpenAI Decisions API	Eligible for Zero Data Retention and HIPAA, US and EU data residency, image inputs	You want portability; you'll be writing an adapter to leave	OpenAI docs
On Azure and buying through Foundry	Microsoft-Decision-1	Listed in the Microsoft Foundry catalog, $0.042 input	Every benchmark behind it is Microsoft's own	Microsoft
Optimizing for the reference implementation	Jev	The model the schema was built for, hosted on three providers	TypeSafe hasn't disclosed its size or base model	The New Stack
Gating one action, once, in an app that already calls an LLM	Keep Structured Outputs or function calling	No new dependency for a single check	Call volume climbs into the thousands an hour	OpenAI docs

Decision-1 isn't a Microsoft 365 Copilot add-on you can switch on. Microsoft says its Copilot team uses the model internally to measure the quality of chat and agent responses, but developer access today runs through Foundry and OpenRouter (Microsoft). Microsoft also says it will rebase the model on its own MAI models and on OpenAI models, beyond the current Qwen3.5-9B base.

Candid cons, by camp

OpenAI

Hosted only, public beta, and gpt-6-luna is the single supported model; the docs say GA is expected "in the coming weeks" (OpenAI docs). The 150 ms figure traces to OpenAI's DevDay materials, compared against about 1.6 seconds for a standard Luna call, not to any outside measurement (The New Stack).

AWS Strands Decider

It's a Strands Labs release, and AWS calls its own agent example "an illustration rather than a recommendation," with thresholds picked by hand (Strands Labs). There's no hosted Bedrock version yet, which The New Stack flags as the gap for anyone who wants this in production rather than on localhost (The New Stack). Like Jev, it takes text input only for now, while OpenAI's, Perplexity's, and Cloudflare's models accept images (The New Stack).

Ollama

Ollama's own post calls both tev1 sizes experimental, and Ollama's accuracy chart for its three models comes from Bespoke Labs' benchmark suite, with Nimble 9B at 75.7% against Jev 1.13 at 76.0% on that set (Ollama). Bespoke Labs built Nimble, so weigh that chart accordingly.

Microsoft-Decision-1

The 36-benchmark accuracy lead and the 2.5x speed edge over the runner-up are from Microsoft's own run, and the post was edited after publication to add Jev to the comparison (Microsoft).

Every vendor in the category

A University of Southern California researcher found an optimizer could flip 61.4% of 508 initially correct Jev decisions by inserting short, natural-looking context, and an open Qwen-based model in the same study flipped at 72.6% (The New Stack, citing the paper). That's a targeted adversarial rate, not an everyday failure rate. It still means any decision that reads user-supplied text needs a second control besides the confidence threshold.

Is this just a gold rush?

TypeSafe's founder thinks most of the followers are. "I get that people think it's a gold rush, but they might be underestimating the difficulty of making the models actually smart," CEO Diogo Almeida told TechCrunch, adding that the current batch "seems more like ML people wanting to implement a cool architecture." He has a point, and also a $7.5 billion valuation to defend.

AWS's Marc Brooker, who started Strands Decider as a homebrew project after trying Jev, frames the demand from the customer end. He told the same TechCrunch reporter that customers wanted "a workflow step that can be structured in a way that is more reliable, thanks to the confidence scores, thanks to the closed domain of answers, [and is] lower latency, potentially lower cost." He also said the cost to build something interesting here is in the hundreds or thousands of dollars (TechCrunch). Jared Palmer reports porting his Kev models to Qwen3.5 for roughly $95 in H100 time (The New Stack).

Both men can be right. Cheap to clone means the interface commoditizes fast, which is good for you as a buyer. Hard to make smart means model quality will separate vendors over the next few months, which is the reason to keep your code on the portable schema so you can swap in whoever wins.

One more caution that applies to every vendor: confidence isn't correctness. TypeSafe's documentation describes confidence as a measure of how concentrated the probability distribution is and tells teams to set thresholds from their own labeled data, per The New Stack. AWS reports that Strands Decider answers at 0.9 confidence or higher were right about 95% of the time on short classification tasks it hadn't seen, per the same article. Run your own labeled sample before trusting any threshold on production traffic.

What to watch through November

JevBench is the closest thing to a neutral scoreboard. It's maintained under the MIT license by Florian Standhartinger and contributors, and its v1.5.4 leaderboard tracked 112 decision systems with Jev in third (The New Stack). If Microsoft, OpenAI, and AWS start reporting against it instead of private suites, comparisons get much easier.

Watch AWS for a hosted Decider in Bedrock, which would remove the main reason to pick a hosted rival over it. Then watch whether OpenAI's "coming weeks" GA lands on time and whether it turns its now-documented schema into an open spec other servers implement or keeps /v1/decisions to itself. If OpenAI opens its own contract, the category carries two standards and you'll want an adapter layer regardless.

Our recommendation for this week: write against System One, run Strands Decider or Ollama's nimble locally on a labeled sample of your own decisions, and only move to a hosted endpoint once you know which threshold your data supports.