AWS Strands Labs released an open-source model on Thursday that removes text generation from the agent decision loop entirely. Instead of predicting tokens, Strands Decider 2B reads a situation, compares its hidden-state representation against each candidate answer, and returns a ranked probability list in a median 115 milliseconds on a consumer GPU, according to benchmarks in the package release. The release arrived on the same day Cloudflare shipped its own decision-model pair, Clef and Clef-flash, as described in the Cloudflare announcement post, suggesting the category TypeSafe AI named “System One models” at its September 15 launch is hardening into a recognizable infrastructure tier rather than remaining a single vendor’s idea.

The model is published at StrandsAgents/strands-decider-2B-hobson-v19 on Hugging Face under an Apache 2.0 license, meaning commercial use, modification, and redistribution require no licensing fees. It is installable in one command (pip install strands-decider) and comes with a command-line interface and an HTTP server, as confirmed by the package’s PyPI listing. No managed hosted inference endpoint exists yet; the bundled server binds to localhost with no authentication layer, which means teams deploying to shared infrastructure need to add access controls themselves.

What Problem Decision Models Solve in Agent Pipelines

An AI agent running in production spends much of its time on decisions that do not require language generation at all: which tool should I call next, is this argument grounded in what the user actually said, does this output meet the requested quality bar, which queue should own this request. Routing each of those through a frontier large language model is slow and expensive by construction — frontier APIs generate text one token at a time whether the task needs a paragraph or a one-word answer.

The decision-model category, now represented by Strands Decider 2B, Cloudflare’s Clef and Clef-flash, and TypeSafe AI’s closed-API Jev, proposes a structural answer detailed in the TypeSafe launch blog: some choices inside an agent loop do not need a language model at all. They need a model that picks reliably from a bounded option set, reports how confident it is, and does so quickly enough to sit on the hot path without becoming the new bottleneck. The TypeSafe team borrowed the term “System One” from cognitive psychologist Daniel Kahneman’s framework distinguishing fast, automatic judgment (System 1) from slow, deliberate reasoning (System 2) — though it is worth noting that even Kahneman’s collaborator Keith Stanovich has since moved away from the System 1/2 framing as overly simplified. The AI analogy is looser than the marketing suggests, but the engineering problem it describes is real.

How the Pointer Head Architecture Works

The core mechanism of Strands Decider 2B is a departure from standard language-model design. The team took Qwen3.5-2B-Base, a 1.9-billion-parameter decoder model produced by Alibaba’s Qwen team and published as open weights, and made a targeted structural change: they removed the language-modeling head — the component responsible for predicting the next word — and replaced it with a pointer head of roughly one million parameters, as described in the project’s architecture documentation.

That pointer head works by comparing the model’s internal representation of the input (captured at a designated position in the sequence) against the hidden-state representations of each candidate option’s final token. The comparison is a dot product, run in a single forward pass, with a masked softmax producing a probability distribution over the options provided. There is no generation loop, no sampling step, no beam search, and no decoding. The model reads the problem once; the answer is the output of one matrix multiplication sequence.

To adapt the base model to this new head without retraining from scratch, the team applied LoRA fine-tuning at rank 16 — a technique from Microsoft Research’s LoRA paper that freezes the pre-trained model weights and injects small, trainable rank-decomposition matrices into each transformer layer, reducing the number of trained parameters by orders of magnitude compared to full fine-tuning. The pointer head itself runs in 32-bit floating-point precision (fp32) to preserve calibration accuracy, while the LoRA-adapted transformer body runs at standard precision.

Because no per-option parameters exist in the pointer head, the model cannot learn that “the first option is usually right,” no cap exists on how many options a question may carry, and label sets are defined at inference time rather than baked into the weights during training. Three question types share the same masked softmax: noul (yes/no, returns a probability between 0 and 1), choice (select one from N candidates), and score (place the input on an ordered rubric).

An additional efficiency: the model reads the context once. Each additional question about the same input appends only its own question tokens, making the marginal cost of batching multiple questions about one piece of text very low. The two-question guard in the Strands agent example — “Is this argument grounded in what the user said?” and “Is this call premature?” — costs approximately 230 milliseconds in the median case on RTX-class hardware, because each question adds roughly 115 milliseconds to the single context read.

This is the second major iteration of the architecture. An earlier version used a “slot head” that mapped the final hidden state to a fixed set of output slots; it performed significantly worse, and every design change since then is documented in the repository’s research logs under a pre-registration discipline: every training run states its predictions and failure conditions before training begins, and the outcome is appended afterward without editing what came before.

Why 2B Parameters, and What That Means for Deployment

The 2B parameter range is a deliberate choice with two arguments behind it. First, it is small enough that the full training recipe can run on hardware a developer already owns — roughly 11 hours on a single NVIDIA RTX 3090 GPU (24 gigabytes of VRAM), or 1 hour and 10 minutes on eight NVIDIA H100s with the fast training flag, per the published training documentation. Second, two billion parameters appears to be a practical sweet spot for this class of tasks: large enough to handle genuine linguistic ambiguity and diverse phrasing, small enough to serve with acceptable latency on a consumer machine.

On an NVIDIA RTX 3090, the model answers a question in a median 115 milliseconds, with a 95th-percentile latency of 299 milliseconds. On an Apple M3 Pro running locally, warm median latency for inputs under 300 tokens is 153 milliseconds; across all tasks, 234 milliseconds. Both figures are end-to-end, including tokenization and network overhead for the bundled HTTP server.

The published training recipe, training data list with source licenses, and evaluation harness are all in the GitHub repository at strands-labs/strands-decider. This combination — open weights, open training recipe, open evals — is what distinguishes the release from Jev (TypeSafe AI’s decision model, which runs only on TypeSafe’s hosted API and whose architecture is not disclosed) and from Cloudflare’s Clef (hosted exclusively on Workers AI, though weights are also published on Hugging Face under Apache 2.0). A developer who cannot route traffic to a hosted API, or who needs to run in an air-gapped environment, or who wants to inspect, modify, and retrain the model is specifically who this release targets.

A note on the base model: Qwen3.5-2B-Base, the transformer torso used here, is published by Alibaba’s Qwen team. Alibaba is a Chinese company subject to China’s National Intelligence Law (2017) and related data-security legislation. That obligation governs Alibaba’s data practices, not the content of open model weights it publishes — the Strands Decider weights are an AWS-produced artifact built on top of those open weights, not a product from Alibaba. Readers operating in sensitive-data environments should note the lineage and assess accordingly.

Benchmark Position and What the Numbers Mean

On JevBench v1, a public benchmark maintained by Benchmark Heaven specifically for decision models, the v19 checkpoint answered 167 of 231 tasks correctly, for an accuracy of 0.723, as shown in the published evaluation results. Two calibration measures accompany that accuracy figure: a Brier score of 0.342 and an expected calibration error (ECE) of 0.052. The ECE figure is practically significant: it means that when the model expresses a confidence of 90 percent, the answers are correct roughly 95 percent of the time on unseen short classification tasks. Unlike standard language models, which generally do not expose calibrated probabilities at all, a decision model’s confidence score is meant to be used as a gating signal — “if confidence is above X, act; otherwise escalate.”

Broken down by the repository’s own tier definitions: perfect accuracy on easy tasks, 87.5 percent on standard tasks, and 50.5 percent on hard tasks — a profile consistent with its intended use case of high-confidence handling of routine routing decisions, with escalation to a heavier model for genuinely ambiguous cases.

On the JevBench v1.4.2 composite leaderboard as of September 25, the v19 checkpoint ranked third out of 33 models in the 2B parameter class. Excluding three models that technically exceed 2B parameters, it sits first out of 30. The Strands team flags an important caveat: Mapika’s competing decider-2b v11 scored 175 of 231 on the Strands team’s own evaluation harness — eight tasks ahead — and a newer Mapika v1.5.4 composite leaderboard was not yet published at time of release.

A note on benchmark scope: JevBench (run by Benchmark Heaven) and Cloudflare’s Decision Index (a 10-task shortlist Cloudflare compiled from the broader Jev Decision Index 0.2.1 suite) are different benchmarks run by different parties on different task sets. Cloudflare reports that Clef scored highest on seven benchmarks from its own 10-task shortlist. Strands Decider 2B’s 0.723 accuracy figure comes from JevBench v1’s 231 tasks. These two results cannot be directly compared without running both models on the same benchmark set. Academic research has also found that decision-model output can be systematically influenced by option-label naming — when an option label carries semantic polarity (e.g., “yes/no” versus “1/0”), decision-flip rates can reach up to 70 percentage points higher on binary classification tasks, a limitation that applies to this model class broadly and not specifically to Strands Decider.

How It Fits Into the Strands Ecosystem

Strands Decider 2B is a product of AWS Strands Labs, a GitHub organization AWS launched on February 23, 2026 as a space for experimental agentic AI projects that are not yet ready for the production-grade Strands Agents SDK. The Strands Agents SDK itself — first open-sourced in May 2025, downloaded 14 million times by February 2026 according to Clare Liguori, senior principal engineer at AWS — reached version 1.0 earlier in 2026, adding multi-agent orchestration patterns and Agent-to-Agent (A2A) protocol support. It runs in production inside Amazon Q Developer, Kiro, and AWS Glue, as detailed in the Strands Agents 1.0 announcement.

Strands Decider 2B is designed to slot into that ecosystem as a lightweight gating layer. The reference integration in the repository is a before_tool_call hook inside a Strands agent that fires two yes/no questions before any external tool call executes — asking whether the arguments are grounded in what the user actually said, and whether the call is premature given the conversation’s current state. If the agent has inferred a city name the user never mentioned, the hook catches the inferred value and requests clarification before the tool fires.

What the Simultaneous Releases Signal

Strands Decider 2B arrived on the same day as Cloudflare’s Clef and Clef-flash, roughly two weeks after TypeSafe AI launched Jev alongside a $40 million seed round led by DCVC, detailed in the TypeSafe AI Jev launch post. Three teams reaching the same architectural conclusion inside a two-week window — build a model that only decides, not one that also generates — suggests the convergence is driven by a shared observation about where agent pipelines waste money and time, not by imitation.

The product differences are meaningful. Jev (TypeSafe) is a closed API; no weights are published, no architecture is disclosed, and self-hosting is not an option. Clef (Cloudflare) publishes weights under Apache 2.0 and runs on Workers AI globally, but its primary delivery mechanism is Cloudflare’s edge network rather than a model you pull and run locally. Strands Decider 2B is the only release in the initial wave that is open in the fullest sense: weights, training data sources, training recipe, evaluation harness, and research logs are all public. Cloudflare’s Clef-flash, at 9 billion parameters, also outweighs Strands Decider 2B at 1.9 billion — useful context when comparing their latency figures, which use different benchmark setups and different hardware.

Whether the category gains broader adoption will depend in part on whether the JevBench leaderboard becomes a standard that agent frameworks reference, or whether each vendor’s proprietary benchmark prevents direct comparison. For now, the simultaneous releases from AWS, Cloudflare, and the earlier TypeSafe launch suggest the window for that standardization question to settle has opened.

What Decision Models Cannot Do

The Strands team is explicit about the model’s limits, and the caveats are structural rather than a matter of scale. The model performs worse than reasoning models on complex, multi-step problems. It cannot write, summarize, code, or answer questions that require synthesizing information into language. The output space is entirely constrained to the options provided in the request: using it for anything outside the choice/noul/score paradigm produces meaningless results. Accuracy drops as input fills with content unrelated to the decision at hand — a property documented in academic research on the model class.

Decision models also do not eliminate the need for LLMs; they are meant to sit alongside them, handling the rote choices while the expensive generative model focuses on the tasks that actually require generation. An agent that replaces its reasoning model with a decision model is an agent that can no longer do the thing it was built for.

Frequently Asked Questions

What is a decision model, and how is it different from an LLM?

A decision model reads a piece of context — a support message, a function-call argument, a user query — alongside a predefined set of typed questions, and returns a probability for each allowed answer. It never generates text. A large language model generates tokens one at a time and can produce any string; a decision model only picks among options explicitly given to it at inference time. That constraint is what allows a single forward pass (no generation loop) and what makes the output format guaranteed — it cannot produce a malformed answer, though it can produce a wrong one.

What is JevBench, and can its scores be compared across the three decision models now available?

JevBench v1 is a third-party public benchmark maintained by Benchmark Heaven with 231 tasks designed for the decision-model class. Strands Decider 2B scored 0.723 (167/231) on JevBench v1. Cloudflare’s launch post cited scores from its own Decision Index, a 10-benchmark shortlist from the broader Jev Decision Index 0.2.1 suite — a different evaluation with a different task set. Direct comparison between JevBench scores and Cloudflare’s Decision Index scores is not valid without running both models on the same benchmark. The statistical noise on JevBench itself is also meaningful: six retrains of a similar recipe showed a standard deviation of 3.2 tasks, so differences under roughly 10 tasks between any two single runs are unresolved at the model level.

Can Strands Decider 2B be run without internet access or an AWS account?

Yes. The weights are published on Hugging Face and can be downloaded and run locally. The Python package includes a command-line interface and an HTTP server that bind to localhost. No AWS account, no AWS credentials, and no internet access during inference are required. The bundled server has no authentication layer by default, so teams running it in shared-access environments need to add their own.

Does the model’s “zero hallucination” property mean the answers are always correct?

No. The model cannot produce an answer that falls outside the option types defined in the request — that is what “zero type errors” means. It can produce an answer that is wrong, with a high confidence score, if the training has not exposed it to the relevant distribution of inputs. The “zero hallucination” framing applies to output format, not to factual accuracy. Academic research has found that option-label polarity (whether a yes/no option is labeled yes/no versus 0/1) can cause significant decision instability in this model class, with flip rates up to 70 percentage points higher depending on label naming.