What Strands Decider Actually Is
In one sentence: a 2B-parameter, open-weight model built specifically for agent decision routing.
The Strands Agents framework has long run a multi-model architecture: a primary LLM handles generation while a cluster of auxiliary models handles classification, routing, and extraction. Strands Decider is a new link in this chain. It doesn't replace the main LLM; it takes over the "what do we do next" judgment layer.
Put more plainly: when you ask an Agent "book me a flight to Shanghai next week," the main LLM is still responsible for drafting the response and invoking tools. But whether it should check flights first or confirm the date, whether to ask about your budget, and where to fall back after a failure—those decisions go to Decider.
Why 2B Parameters Could Handle Decision Routing
Here's a counterintuitive fact: decision routing is fundamentally a classification-and-ranking problem, not a generation problem.
The scope of decision routing is narrow: given the current state and a set of candidate actions, pick the best next step. It doesn't write a polished reply or explain why it chose A over B. That's a completely different difficulty tier from "write a novel."
The Strands team's reasoning rests on this point. Their launch post explicitly says the model is trained for "agent decision routing," with a curated set of trajectories as training data. The benefits break down into three:
- Low inference cost. A 2B model runs on a single GPU or even on-device, with latency and per-call cost an order of magnitude lower than calling GPT-4 or Claude for planning.
- Self-hostable. Open weights mean deployment in your own datacenter with no data leaving the network.
- Compliance-friendly. Decision trajectories routinely include user intent and tool-call context—things that carry regulatory risk when shipped to a hosted LLM.
One more point that's often overlooked: 2B models tend to produce more stable outputs. Decision routing demands consistency, and large models sometimes "get creative," issuing different actions for the same state. Smaller models are simply more controllable.
How It Differs from ReAct and Function Calling
Today, agent decision-making roughly falls into three camps:
- The main LLM plans everything. ReAct and Plan-and-Solve both work this way—the primary model generates the reply and decides the next step in the same pass.
- A large model acts as a router. Use something like GPT-4 as a classifier to dispatch requests to specialized expert models.
- Small model for routing, large model for generation. This is the Strands Decider approach.
The first two share a problem: decision cost scales with the size of the main model. Run Claude as your primary, and routing costs Claude-level money. Scale up to high-concurrency agents and your bill goes orbital.
The third path decouples decision from generation. Decisions go to a small model (cheap, fast, controllable); generation stays with the large model (expensive, slow, but high quality). Only the steps that genuinely need a frontier model hit a frontier model. Everything else is small-model scutwork.
This isn't a Strands original. LlamaIndex's routing work and Haystack's classifiers have explored similar directions. But Strands is the first to ship decision routing as a standalone, open-weight, self-hostable model.
How the HN Crowd Reacted
The post landed on the Hacker News front page with a score of 104 and around 20 comments—a solid mid-to-upper showing.
A few representative comment threads:
- Self-hosting advocates: "Finally, a decision model we can deploy ourselves instead of shipping user intent to OpenAI every time."
- Skeptics on the 2B size: "Is 2B really enough? Real-world decision trees get complex; small models haven't seen enough trajectories."
- Benchmark-minded: "Any head-to-head with a GPT-4 router? No numbers, no production."
- Architecture-curious: "Multi-model collaboration is the right direction. The main model shouldn't be doing everything."
The last two comment threads converge on the same gap: there's no public comparison data. Which brings us to the next point.
The Testing Gap: Nobody Has Run This in Production
Honestly, the blog leaves out more than it covers.
- No benchmark numbers. What does 2B score on SWE-bench, τ-bench, or other agent evaluations?
- No latency data. How many milliseconds per decision inference? How much does that save over using Claude as a router?
- No cost comparison. What's the actual TCO of self-hosting a 2B versus hitting an API?
- No "decision accuracy" metric. Given the same state, how often does Decider's choice match a large-model router's choice?
These are all pre-production must-knows. Strands has shipped "the model exists" and "the architecture makes sense," but not "it actually works well."
My recommendation: pilot it on internal low-risk scenarios first—FAQ routing, tool-call dispatch—and don't go straight to core workflows.
Editorial Take
If this approach holds up, agent architecture shifts from "one big model does everything" to a pipeline of small-model routing plus large-model generation. Cost and latency theoretically drop an order of magnitude. That's not incremental optimization; it's a reorganization of where the work happens.
But 2B models have a hard ceiling on generalization. Decision routing looks like a classification problem until you hit real-world "states"—users changing their mind mid-flow, tools returning malformed errors, contexts getting truncated by length limits. Those long-tail cases are exactly where a 2B model that hasn't seen them in training will fall over. What runs reliably today is structured tasks: FAQ routing, tool dispatch, fixed-flow customer support. 2B is fine in those.
How this differs from prior work: most earlier routing models were closed-weight, API-gated, and locked to a specific framework (certain LangChain components, for example). Strands Decider is the first to ship a decision-routing model as standalone open weights that can plug into any agent framework. That turns "small-model routing" from an internal trick into a reusable infrastructure layer.
My read: worth tracking, but at least two versions away from "small models replace big ones for decisions." Version one proves it runs. Version two fills in benchmarks and tooling. Version three is when production becomes plausible. Strands Decider today is somewhere around version 0.5.
One thing I can't verify: stability across multi-turn, complex tool-chain scenarios. The blog doesn't address it either. If anyone's run it on real traffic, drop a note in the comments.
Sources: