AWS Builder Center

Builder Center

Strands Decider 2B: Local Setup and Testing

Strands Decider 2B: Local Setup and Testing

Step-by-step guide to install, configure, and run AWS Strands Decider 2B locally using WSL2, including API testing and Multi-RAG routing examples.

Ujjwalkumar B Soni

🚀 Running AWS Strands Decider 2B Locally for Multi-RAG and Agentic AI Applications

As GenAI applications evolve, one challenge appears repeatedly:
How do we make reliable decisions before invoking an LLM?
Questions such as:
  • Which datasource should answer a request?
  • Should I call Jira, PLM, or Confluence?
  • Do I have enough context to answer confidently?
  • Which tool should my AI agent invoke?
are often delegated to LLMs.
Recently, I explored AWS Strands Decider 2B, a lightweight decision model designed specifically for routing, classification, validation, and workflow orchestration.
Unlike traditional LLMs, Strands Decider doesn't generate arbitrary text. Instead, it chooses from predefined options and returns a confidence score, making it an excellent fit for Agentic AI and Multi-RAG architectures.
In this article, I'll walk through the complete setup, testing, and usage of Strands Decider 2B on Windows using WSL2.

Why Use a Decision Model?

A typical GenAI architecture looks like this:
The LLM is responsible for both:
  1. Making decisions
  2. Generating answers
A cleaner architecture separates those responsibilities:
Benefits include:
  • Better routing accuracy
  • Lower hallucination rates
  • Faster decisions
  • More observable workflows
  • Improved agent governance

Environment

The following environment was used:
  • Windows 11
  • WSL2
  • Ubuntu
  • Python Virtual Environment
  • AWS Strands Decider 2B

Step 1: Verify WSL2 Installation

Open PowerShell and run:
1
wsl -l -v
Expected output:
1
2
NAME STATE VERSION
Ubuntu Running 2
Start Ubuntu:
1
wsl -d Ubuntu

Step 2: Create a Workspace

1
2
3
mkdir -p /mnt/c/GENAI/strands

cd /mnt/c/GENAI/strands

Step 3: Install Required Dependencies

Update Ubuntu:
1
sudo apt update
Install required packages:
1
2
3
4
5
6
7
8
sudo apt install -y \
python3 \
python3-pip \
python3-venv \
python3-dev \
build-essential \
gcc \
g++
Verify installation:
1
2
python3 --version
gcc --version

Step 4: Create a Virtual Environment

Create a Python virtual environment:
1
python3 -m venv .venv
Activate it:
1
source .venv/bin/activate
Upgrade pip:
1
pip install --upgrade pip setuptools wheel

Step 5: Install Strands Decider

Install the package:
1
pip install strands-decider
Verify:
1
strands-decider --help

Step 6: Discover Available Models

Install Hugging Face Hub & Authenticate after installation:
1
2
3
pip install huggingface_hub

hf auth login
List available models:
1
python -c "from huggingface_hub import list_models; [print(m.id) for m in list_models(search='strands')]"
Model used in this tutorial:
1
StrandsAgents/strands-decider-2B-hobson-v19

Step 7: Start the Local Inference Server

Launch the model:
1
strands-decider serve StrandsAgents/strands-decider-2B-hobson-v19 --device cpu
Successful startup:
1
2
Application startup complete.
Uvicorn running on http://127.0.0.1:8000
The first startup downloads and caches model weights automatically.

Step 8: Verify the API

Open:
1
http://127.0.0.1:8000/docs
Or verify using curl:
1
curl http://127.0.0.1:8000/openapi.json

Understanding Question Types

Strands Decider supports three types of decisions.

Choice Question

Used when selecting one option from multiple choices.
1
2
3
4
5
6
7
8
9
10
{
"type": "choice",
"instructions": "Select the best datasource.",
"criteria": {
"PLM": "Engineering data",
"JIRA": "Issue tracking",
"CONFLUENCE": "Documentation",
"UNKNOWN": "No matching source"
}
}

Noul Question

Used for binary true/false decisions.
1
2
3
4
{
"type": "noul",
"instructions": "Determine whether this statement is true."
}

Score Question

Used for ranking or scoring.
1
2
3
4
5
6
7
8
9
10
11
{
"type": "score",
"instructions": "Rate the sentiment.",
"criteria": [
"Very Negative",
"Negative",
"Neutral",
"Positive",
"Very Positive"
]
}

Testing with Python

Create a file named:
decider_demo.py

Sample Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import requests
import json

payload = {
"state": "User wants ECO information",
"questions": {
"datasource": {
"type": "choice",
"instructions": "Select the most appropriate datasource.",
"criteria": {
"PLM": "Engineering changes and parts",
"JIRA": "Issue tracking system",
"CONFLUENCE": "Documentation repository",
"UNKNOWN": "No suitable source"
}
}
}
}

response = requests.post(
"http://127.0.0.1:8000/v1/systemone",
json=payload
)

print(json.dumps(response.json(), indent=2))
Run:
1
python decider_demo.py

Sample Response

1
2
3
4
5
6
7
8
{
"answers": {
"datasource": {
"choice": "PLM",
"confidence": 0.94
}
}
}
The output includes both:
  • Selected option
  • Confidence score
This makes the model particularly useful for orchestration and routing scenarios.

Multi-RAG Routing Example

A common use case is routing user queries to the correct retrieval system.
1
2
3
4
5
6
7
8
9
10
11
12
13
decision = response["answers"]["datasource"]["choice"]

if decision == "PLM":
plm_rag.search(query)

elif decision == "JIRA":
jira_rag.search(query)

elif decision == "CONFLUENCE":
confluence_rag.search(query)

else:
print("No reliable datasource identified.")
Instead of letting the LLM guess where information exists, the decision model chooses the optimal source first.

Real-World Enterprise Use Cases

I see significant value for Strands Decider in:

Agentic AI

  • Tool selection
  • Workflow orchestration
  • Agent handoffs

Multi-RAG Architectures

  • Retrieval routing
  • Data source selection
  • Context validation

Engineering Applications

  • PLM assistants
  • Engineering change requests
  • Part classification

Enterprise Search

  • SharePoint routing
  • Confluence routing
  • Jira ticket search

Governance

  • Confidence-based decisions
  • Approval workflows
  • AI guardrails

Architecture Pattern

1
2
3
4
5
6
7
8
9
10
11
12
13
14
User Query
|
v
Strands Decider
|
+-------------------+
| |
v v
PLM RAG Jira RAG
| |
+--------+----------+
|
v
LLM Response
This pattern helps ensure the right knowledge source is selected before retrieval and generation occur.

Final Thoughts

One lesson I've learned while building enterprise GenAI applications is:
Not every problem requires text generation.
Decision making and text generation serve different purposes and often benefit from different models.
By introducing a decision layer before retrieval and generation, organizations can build systems that are:
  • More reliable
  • Easier to govern
  • Easier to debug
  • Less prone to hallucinations
For anyone building Agentic AI, Multi-RAG platforms, or enterprise copilots, Strands Decider is worth exploring.

Repository

GitHub Repository: https://github.com/ujjwalbsoni/strands-decider-end-to-end

About the Author

Ujjwalkumar Soni

Passionate about Agentic AI, Enterprise GenAI Platforms, RAG Architectures, and Intelligent Knowledge Systems.
Connect with me to discuss AI Agents, Multi-RAG systems, MCP, AWS, and Enterprise AI solutions.
#AI #AWS #GenAI #RAG #AgenticAI #Python #MachineLearning #LLM #EnterpriseAI #AWSStrands
# ai# agentic-ai# rag# strands# strands-agents
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article