By ByteBot
AWS released Strands Decider 2B on October 1 — a 2-billion-parameter model that writes zero words of text. It makes decisions: pick a tool, answer yes/no, score an output on a rubric. It runs locally, answers in 115ms on a consumer GPU, and costs nothing per call. Most of the tokens your agent burns aren’t on hard reasoning — they’re on whether to call tool A or tool B. Strands Decider routes those micro-decisions without touching a frontier API.
What It Does (and What It Doesn’t)
Strands Decider is a classification engine, not a text generator. It answers three types of typed questions: noul (yes/no with calibrated probability), choice (pick one option from N candidates), and score (rate an input on an ordered rubric). That’s the entire surface area.
The calibrated confidence matters in production. A probability of 0.8 means the model is right roughly 80% of the time — so you can set a threshold (say, 0.7) and fall back to a larger model when Decider isn’t confident. That’s a real workflow, not marketing copy.
The Architecture
AWS built Strands Decider on Qwen3.5-2B-Base, then replaced the standard language-model head with a pointer head of roughly one million parameters. The pointer head compares hidden states — the hidden state at the <answer> position against the hidden state at each option’s last token — and runs a masked softmax to produce per-option probabilities.
Because the pointer head has no per-option parameters, the option list comes from the request. You’re not limited to a fixed label set baked into the weights. A rank-16 LoRA adapter handles the fine-tuning on decision tasks. One forward pass, no decoding loop.
Benchmarks: Honest Read
On the JevBench public set (231 tasks), version 19 scores 0.723 accuracy — 50th of 89 systems overall, 3rd in the 2B parameter class. Version 21 reaches 0.762. TypeSafe’s Jev hosted models score 0.83–0.93. That gap is real and AWS doesn’t hide it.
The more useful number: on the easy tier — routine micro-decisions that make up most agent traffic — Strands Decider scores 100%. The hard tier (edge cases, ambiguous routing) drops to 50.5%. If you’re using it for “which of these three tools should I call,” it works. If you’re using it to decide whether to execute a financial transaction, it doesn’t.
The CPU Catch
The 115ms figure everyone is quoting comes from an RTX 3090. On CPU, the picture changes significantly:
- 8-thread Xeon: 1.6 seconds on short inputs, 16–18 seconds at 3,000+ token context
- Bedrock AgentCore microVMs (CPU-only): 9–13 seconds per decision
- Bedrock AgentCore Runtime Instances (GPU): fast
On CPU in AgentCore, one decision costs more in latency than an average Nova Pro answer costs in dollars — roughly $0.00033. If you’re considering Strands Decider as a cost-saving measure on CPU, run the math before committing. The GPU requirement is a real deployment constraint for teams that don’t already have GPU capacity in their agent stack.
How to Try It
Install and serve locally in two commands:
pip install strands-decider
strands-decider serve StrandsAgents/strands-decider-2B-hobson-v21 --port 8099The practical integration pattern uses an InterventionHandler that gates tool calls before execution:
class Gatekeeper:
def before_tool_call(self, tool_name, tool_args, context):
answer = client.noul(
question=f"Is calling {tool_name} with these args safe?",
context=str(context)
)
if answer.probability < 0.7:
return Guide("Reconsider this tool call")
return Proceed()Weights, training data, and training scripts are all Apache 2.0 on Hugging Face and GitHub. The official announcement includes a benchmark deep-dive and the full architecture writeup.
Strands Decider vs. Jev: When to Use Which
ByteIota covered TypeSafe AI’s Jev when it launched. The short version: Jev is the accuracy leader, Strands Decider is the open-source, self-hostable alternative. Neither is universally better.
| Strands Decider 2B | Jev | |
|---|---|---|
| JevBench score | 0.762 (v21) | 0.83–0.93 |
| GPU latency | 115ms | Not published (hosted) |
| CPU latency | 1.6s–18s | N/A |
| License | Apache 2.0 | Proprietary |
| Self-hostable | Yes | No |
| Cost | Free (local) | Per-call API |
Use Strands Decider if you’re already on Strands Agents, have GPU capacity, and want to cut API costs on routine routing decisions. Use Jev if you need the highest accuracy available and are comfortable with a hosted API dependency. The decision model category is new enough that both products are worth watching — AWS shipping this in open source is good for the ecosystem regardless of where the benchmarks land today.
