Strands Decider 2B: a small open decision model for agents

Another entrant has joined the Jev class of decision models. Strands Decider 2B was released on October 1 by the Strands project, the open-source agent SDK behind the harness we covered in Strands harness. TechCrunch describes it as an AWS release. The post, repository and model card we read come from Strands’ own accounts (the GitHub organizations strands-agents and strands-labs, the Hugging Face organization StrandsAgents) and do not state who owns the project, so we attribute it to the Strands team. Its training recipe ran on an AWS p5.48xlarge host and the example agent uses Amazon Bedrock. All figures below are the Strands team’s, not independently verified.

What decision models are

The post places Strands Decider in the class that TypeSafe’s Jev opened this month, which TypeSafe calls System One models. Instead of generating text, a decision model picks between given options (is this about the coffee machine, yes or no; which of three languages) or rates something on a scale, and attaches a reliability score to each decision. The trade-off, as Strands states it: faster and more capable at a given size, but “significantly worse” than reasoning models on complex problems, and unsuited to coding, chatbots or summarization. We have followed this class through Jev and Laya-MLX, OpenDecider, CLM-8B, Jeeves and Jeff.

How it is built

Strands takes a pretrained LLM, Qwen3.5-2B-Base, removes the language-model head and replaces it with a small pointer head. The head scores each option by comparing that option’s hidden state with the hidden state at the <answer> position, in a single forward pass with no decoding loop. Trained parts are rank-16 LoRA adapters and the head, about one million parameters. The released model is v19 of a second architecture; a first version with a “slot head” performed significantly worse. Training targets include the output distributions of a frozen Qwen/Qwen3.5-4B teacher, plus public datasets and synthetic rows.

What the numbers say

On the 231 public tasks of JevBench, the model card reports:

Measure	Value
Accuracy	72.3% (167 of 231)
Brier score (lower is better)	0.348
Calibration error (ECE)	0.050

Strands says this is 3rd of 33 models in the 2B class, and 1st of 30 excluding the models just over 2B, and that the model gets 100% of JevBench’s easy tasks. The model card also lists internal held-out sets from its own recipe, such as 82.2% on a boardgame set, 87.2% on ContractNLI and 88.4% on MuSiQue, which are not an external benchmark.

The chart shows more than the headline. It marks other systems on the same 231 tasks in green, and by our reading a frozen Qwen3.5-4B sits at roughly 0.81 accuracy and a Brier score near 0.25, ahead of v19 on both. That model is the teacher, so it is not surprising, and the pitch is not top accuracy: it is a 2B model that answers in one pass with a confidence score. The chart also marks two points labelled strands-decider-2b v10 and v11 among “other systems”; by our reading the v11 point, near 0.76 accuracy and a Brier score near 0.32, is also ahead of v19 on both axes. The post does not explain what these two points are. The README adds a calibration claim: on short classification tasks it has not seen, answers at confidence 0.9 or higher are right about 95% of the time. The model card limits where that is established (see below).

On speed, the post says the median decision takes around 115 ms on widely available hardware, and around 153 ms for small tasks on an M3 MacBook. Its chart, for v18 on an RTX 3090 with one question per request through the local server, shows a 106 ms median, 296 ms at p95 and 309 ms at p99, after leaving out a 7.7-second warm-up request. Latency grows roughly linearly with prompt length, reaching about 300 ms at around 2,500 to 3,000 tokens.

We do not set these figures beside the numbers in our Jeff and Jeeves articles. Those projects used their own samples and hardware, so the figures are not comparable.

Where it is weak

The model card is direct about limits:

• Documents more than questions. With the state and options fixed, a changed question often gets the same answer.
• Long, multi-step documents are the weak spot: JevBench’s hard tier scores far below its easy tier.
• Yes/no and scoring tasks transfer poorly to rubrics unlike the training mix. Train on a rubric like yours.
• Calibration is one temperature per primitive, fitted on held-out short classification. The card says to measure on your own traffic before trusting a threshold.
• Public training data means inherited domains and label noise.

Using it, and a tool-call guard

The quickest route is pip install strands-decider and the strands-decider ask CLI, which prints a probability per option and a confidence. A local server mode binds to 127.0.0.1 and has no authentication, so the card says to use it for local experiments only.

The post’s example is the most interesting part. In Strands’ intervention system, a handler runs before any tool call and returns a typed action: Proceed, Deny, Confirm (stop and ask a person) or Guide (hand the turn back to the model with feedback). The example asks Strands Decider two yes/no questions about a proposed get_weather call: are the arguments grounded in what the user said, and is it premature to call at all. When the agent guesses a city nobody mentioned, it asks which city the user meant instead. Strands labels it “an illustration rather than a recommendation,” with questions, threshold and policy chosen by hand, and notes a Strands team library for decision-model integration is coming. It echoes the tool-call guard idea in our Claude Code mods note, with a model making the call instead of a rule.

License and data

The model and code are Apache-2.0, and so is the Qwen3.5-2B-Base it builds on. The training data is a mix of public Hub datasets whose license tags include Apache-2.0, CC-BY, CC-BY-SA, CC0, MIT and also other, unknown and none, plus synthetic rows. Anyone planning commercial use should read the repository’s data/sources.md. Retraining takes about 11 hours on one RTX 3090 or about 1 hour 10 minutes on eight H100s, per the card.

What to watch

• Independent evaluations on JevBench and other tasks, especially long documents.
• Whether the confidence bands hold off the short-classification tasks they were fitted on.
• The integration library the Strands team says is coming.
• The OpenAI Decisions API, announced at DevDay (see our DevDay article), which TechCrunch says arrived the same week. As of this writing we have found no OpenAI documentation for it.

Editorial review: October 1, 2026 (AI). Prepared from the Strands blog post, the Hugging Face model card and the GitHub README, all read on the same day, and the figures reproduced from the Strands post with credit. All benchmark and latency figures are the Strands team’s and were not independently verified. We did not run the model.