Skip to content

Strands Decider 2B Tutorial: Run a Local Decision Model for AI Agents

Learn how to install Strands Decider 2B locally, run bounded AI decisions, use its confidence output, expose it over HTTP, and place it before agent tool calls.

Strands Decider 2B Tutorial: Run a Local Decision Model for AI Agents

On this page

Amazon's Strands Agents team released Strands Decider 2B on October 1, 2026, giving developers a small open-source model designed to make bounded decisions instead of generating paragraphs of text. This Strands Decider 2B tutorial shows how to install it locally, ask choice, yes-or-no, and scoring questions, expose it through a local HTTP server, and understand where its confidence output belongs in an AI agent.Β 

Why Strands Decider 2B does not work like a normal LLM

A large language model (LLM) normally generates text one token at a time, which makes it useful for writing, coding, summarization, and open-ended reasoning. Strands Decider takes a narrower approach: you give it some state and a fixed question with defined answers, and it scores those possible answers rather than composing a new response. The released model has about 1.9 billion parameters and is built from a Qwen3.5-2B base model with a LoRA adapter and a small pointer head. Because there is no normal language-model output head, the model is intended for decisions such as routing, tool selection, argument checking, triage, guardrails, and evaluation rather than general conversation.Β 

That distinction changes how you should use it. A request such as β€œwrite a product description” is the wrong workload because there is no text-generation stage for producing the description. A request such as β€œwhich team should receive this ticket: billing, sales, or retail?” fits the model because the answer is constrained to known options. The model also returns confidence information, giving an agent another signal it can use before accepting a decision. If you already build a tool-using agent, this makes Decider useful as a small decision layer placed before a more expensive model or tool call.

What you need before starting the Strands Decider 2B tutorial

The simplest route is a Python environment with Python 3.10 or newer and the strands-decider package. The project is distributed under the Apache 2.0 license, and the reference checkpoint is available through Hugging Face. The package was published as version 0.1.0 on October 1, 2026, so this tutorial uses the initial public release rather than assuming an older package version.Β 

Important: the model downloads its base weights the first time it is used. The project supports CPU and Apple silicon for serving, while the published performance measurements include an NVIDIA RTX 3090 and an Apple M3 Pro. Your actual latency will depend on hardware, task size, and runtime conditions.Β 

Step 1: Create a Python environment

Start by creating a clean Python environment so the new package does not conflict with dependencies from another AI project. On Windows, macOS, or Linux, the standard virtual-environment module is enough for this first test. Activate the environment before installing the package. When activation succeeds, your terminal should use the environment's Python executable rather than the system installation.

python -m venv .venv
# Windows
.venv\Scripts\activate

# macOS or Linux
source .venv/bin/activate

Check the Python version before continuing. The published package metadata requires Python 3.10 or newer, so an older interpreter should be upgraded rather than worked around. This check prevents a confusing installation failure later in the process.Β 

python --version

Step 2: Install Strands Decider 2B

With the environment active, install the package from PyPI. The package provides the strands-decider command used throughout the project's getting-started examples. You do not need an API key for this local workflow because the model is downloaded and executed on your machine. After installation completes, the command should be available from the same terminal.Β 

pip install strands-decider

Verify that the command is installed before loading the model. If the shell cannot find strands-decider, the virtual environment is usually not active or the package was installed into a different Python environment. Fix that before proceeding, because every later command depends on the same installation.

strands-decider --help

Step 3: Ask the model a multiple-choice question

The choice question type is the easiest way to understand the model. You provide a piece of state, a question, and a comma-separated set of possible answers. Decider scores those options and reports the selected option together with probability-like scores for the available choices. The project documentation demonstrates this pattern by routing a customer problem to billing, sales, or retail.Β 

strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "My online payment has failed three times and I need help." \
  --choice "Which team should handle this?=billing,sales,retail"

The important part of the result is not the wording of a generated answer because there is no generated explanation. Instead, the model selects one of the options you supplied and reports confidence information. That makes the output easy for application code to consume: your program already knows every permitted destination before the model runs. If the confidence is too low for your workflow, your application can send the case to another model or ask a human rather than treating the first choice as certain.Β 

Step 4: Use a yes-or-no decision with noul

The second question type is noul, which represents a yes-or-no decision. Instead of giving several named choices, you describe the condition you want the model to judge. The output is a value between zero and one, where a value closer to one indicates stronger support for β€œyes.” This is useful for checks such as whether a proposed tool call is premature, whether text contains a particular property, or whether an agent should stop for clarification.Β 

strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "The customer says their payment failed but gives no order number." \
  --noul "Does this request need clarification before the agent continues?"

Do not confuse the confidence-like output with a guarantee that the decision is correct. The project's own documentation reports calibration measurements on its evaluation set, but it also warns that calibration was established on particular tasks and should be measured on your own traffic before using a threshold in production. That distinction matters because an agent that automatically blocks every decision below a chosen threshold is making a product-policy decision on top of the model's output.Β 

Step 5: Score text against an ordered scale

The score type lets you define an ordered set of labels instead of selecting a single category. For example, you can provide low, medium, and high when evaluating urgency. The model returns the distribution across those positions, allowing an application to treat the result as a graded signal rather than a simple class. This is different from asking an LLM to invent a number because the possible scale is specified by the application.Β 

strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "The customer has been unable to access their account for four days." \
  --score "How urgent is this request?=low,medium,high"

Use ordered labels carefully. The model's score type is intended for a defined scale, so the difference between adjacent choices needs to have a meaningful order. If β€œbilling,” β€œtechnical,” and β€œsales” are the choices, that is classification and choice is a better fit. If the options describe increasing levels of the same property, score gives the application a more natural representation.Β 

Step 6: Run several decisions against the same state

One of the more useful details is that multiple questions can be evaluated against the same state in a single command. This matters when an agent needs several small checks before proceeding, because the model does not need to reload the same state separately for every question. The project demonstrates combining choice, noul, and score in one invocation.Β 

strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "A customer says a payment failed twice and asks which team can help." \
  --choice "Which team should handle this?=billing,sales,retail" \
  --noul "Does the customer need immediate clarification?" \
  --score "How urgent is the request?=low,medium,high"

This pattern is where a decision model starts becoming useful inside an agent rather than being merely a classification demo. One model invocation can produce several bounded signals that your application can turn into routing, validation, or escalation rules. For a reliable agent, those checks can form a small control layer around actions that should not happen automatically. The decision model still does not replace the main reasoning model; it handles the narrow questions that can be expressed with known answers.Β 

Step 7: Expose Decider as a local HTTP service

If your application is written in another language, you do not have to embed the Python model directly into that application. Strands Decider includes a local server mode that exposes a simple HTTP endpoint for submitting state and typed questions. The server binds to 127.0.0.1 and does not provide authentication, so the published model card explicitly describes this mode as suitable for local experiments rather than an exposed production service.

strands-decider serve StrandsAgents/strands-decider-2B-hobson-v19 --port 8000

Leave that terminal running and use another terminal to send a request. The API accepts a state string and a collection of named questions, then returns the model name, answers, token usage, and measured latency for the request. This separation lets a PHP, Node.js, Go, or other application communicate with the local Python process without embedding the model itself.Β 

curl -s localhost:8000/v1/systemone \
  -H "content-type: application/json" \
  -d '{
    "state": "The customer has not provided an order number.",
    "questions": {
      "needs_clarification": {
        "type": "noul",
        "instructions": "Does the agent need clarification before continuing?"
      }
    }
  }'

A successful response contains a named answer under the answers object. The reference example also exposes input tokens, output tokens, and latency, which can help you observe how the local service behaves as your questions become larger. Because the server has no authentication, keep the listener local unless you add an appropriate security layer yourself.Β 

Step 8: Put the decision before an agent tool call

The most interesting application is not asking Decider isolated questions but using its result to control an agent. Strands' own example places a decision check in a before_tool_call intervention, where the proposed tool call is inspected before execution. The example checks whether the arguments are grounded in information the user actually supplied and whether it is premature to call the tool. If those checks fail, the agent asks for clarification instead of executing a guessed action.

This pattern is valuable because the expensive language model can remain responsible for the difficult reasoning while the smaller decision model handles repetitive checks. For example, a weather agent can generate a proposed location, but a Decider check can ask whether that location actually came from the user's message. A failed check can produce a clarification step rather than allowing the tool call to continue. The same architecture can be adapted to routing, policy checks, argument validation, and other bounded decisions, although the thresholds and questions need to be designed and tested for the particular application.Β 

What the published benchmarks actually tell you

The reference repository reports 167 correct answers out of 231 tasks on the public JevBench v1 set, or 72.3 percent accuracy, with a Brier score of 0.342 and expected calibration error of 0.052 for the reported v19 evaluation. It also reports a median latency of 115 milliseconds per question on an RTX 3090 under Windows Subsystem for Linux 2, while a warm Apple M3 Pro measurement for shorter tasks is reported at 153 milliseconds. These numbers describe specific evaluation conditions rather than a guaranteed speed or accuracy level for your application.Β 

MeasurementPublished resultWhat it means
Model size1.9 billion parametersSmall enough for local experimentation compared with frontier models.
JevBench v1167 of 231The reported public-set accuracy is 72.3 percent.
RTX 3090 latency115 ms medianA local reference point for short decision workloads.
M3 Pro latency153 ms warm median for under-300-token tasksShows that Apple silicon can also serve the model locally.

The limitations are just as relevant as the headline numbers. The repository says long, multi-step documents are a weak spot, and it warns that changing the question while keeping the same state and options can produce the same answer in some situations. It also says confidence bands were established on particular short classification evaluations, so developers should measure calibration on their own traffic before treating a threshold as trustworthy. That makes Decider a specialized component, not a drop-in replacement for a reasoning model.Β 

Where Strands Decider 2B fits in a real application

Strands Decider 2B makes sense when the answer space is known before the model runs. Model routing, tool selection, argument validation, request triage, policy classification, and lightweight evaluation all fit that pattern. Open-ended coding, document writing, summarization, and complex reasoning do not, because those tasks require generated language rather than a bounded choice. The model's small size and local execution make it particularly interesting as a supporting component around an agent rather than as the agent itself.Β 

The practical next step is to take one repetitive decision from an existing agent and express it as a precise choice, noul, or score question. Run that decision locally, record both the selected answer and its confidence, and compare those results with the decisions your current workflow makes. If the model is unreliable for that particular question, the correct response is to change the question, use a different model, or keep the larger reasoning model in the loopβ€”not to hide the uncertainty behind a fixed threshold. The project is open source with its training data, scripts, evaluations, and research history available, so developers can also inspect how the reference model was built before deciding whether to adapt it for a specific agent.Β 

Copy this post

0 Comments

No comments yet. Be the first to share your thoughts.

Join the conversation

Log in or create a free account to leave a comment. You can edit or delete your own comments any time.