On October 1, AWS Strands Labs open-sourced a small model. Strands Decider 2B. A model that "decides," as the name says.

The unusual part: it writes nothing. It picks one option from a given set and returns probabilities and confidence for each. Why would anyone need that? Because agents currently burn long reasoning on every "what next?" moment.

What a decision model is: nicknamed System One

When TypeSafe launched Jev on September 15, it called this class "System One" models. As the Jev post explains, it is AI that decides without writing sentences. Feed it state and it returns choices, scores, or yes/no probabilities.

Regular LLM:       state → long text (many tokens, slow)
Decision model:    state + options → pick + probabilities (one pass, fast)

Strands Decider 2B is the open-source take on this wave. Built on Qwen3.5-2B, it drops the next-word prediction part and replaces it with a small "pointer" component (about a million parameters) that scores answer options. It trained with a rank-16 LoRA update, and the architecture is called Hobson. Apache 2.0 means you can download it, inspect it, and retrain it.

The difference from Jev is access. Jev is API-only ($0.042 per million input tokens, no output fee) with closed weights. Decider ships weights plus the full training recipe, so it runs locally and can be modified. Reports say OpenAI announced something similar on September 30, so several labs are racing for the same slot.

Why it matters: agent choices are expensive

Open up an agent loop and a surprising number of steps are "choices."

- Which tool next (tool selection)
- Which model gets this task (routing)
- May it execute (approval)
- Retry or hand to a human (retry policy)

Today a frontier LLM answers all of these with long reasoning. Slow and pricey. AWS reports Decider decides in the tens of milliseconds on short tasks and under 100 milliseconds on common hardware and inputs. At roughly the 1.9B scale it runs on laptops and local servers.

The shifting shape:
Before: every choice calls the frontier (slow + expensive)
After:  Generator (creates) + Decider (picks) + Verifier (checks)

The classify step from the routing implementation post is exactly the Decider slot. That post said the classifier could stay simple. Now there is an open model built for that simple classifying job.

A CLI example: what it looks like

The official repo example gives the feel.

$ strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "Help! My payouts have been failing for 3 days!" \
  --choice "Which team should handle this?=billing,sales,retail"

choice_0 -> billing (confidence 0.768)
billing 0.845  retail 0.091  sales 0.064

Yes/no questions work too. Ask something like --noul "Does this convey urgency?" and it answers on a 0 to 1 scale, closer to 1 leaning Yes. The repo also ships Strands agent examples (examples/strands/): the agent itself runs locally, asks a locally running Decider, and leaves generation to the default LLM.

CodeBridge Mini Lab: carve out one choice

1. Pick one choice point in your agent:
   candidates: tool selection / routing / approval / retry policy

2. Log for 2 weeks on frontier calls:
   - choice call count, average tokens, average latency, cost

3. Compare with a Decider-class swap:
   [ ] Same picks (agreement rate)
   [ ] How much faster (latency gap)
   [ ] How much cheaper (cost per choice)
   [ ] Below-confidence handling (re-check with frontier under threshold)

4. Call it:
   agreement 95%+ with 10x latency win means split it off
   set the threshold from the confidence distribution (low confidence goes up)

The key is confidence. A Decider returns "how sure" alongside the answer. Route only low-confidence cases to the pricey model and you get the same escalation pattern as the Sonnet high-effort post. Small model first, big model second. Slots assigned.

Conclusion: split how you ask

One line to close.

"What next" and "how to do it" belong to different models.

The era of asking the writing model to also choose is ending. Choices go to fast, cheap, confidence-reporting models. Generation and verification keep their own seats. One task for today: find the single most-called choice in your agent and turn on logging. That number picks your next architecture.

Further reading

References

Go deeper with a course

If you want practice designing choice, delegation, and verification as a structure, this course builds harness, loop, and graph layers exactly like the role split here.