Running AWS Strands Decider 2B Locally: A Complete Setup Guide for AI Routing & Multi-RAG Systems

As GenAI applications become more sophisticated, one challenge continues to surface:

How do we make reliable decisions before invoking an LLM?

For example:

Traditionally, we let an LLM make these decisions.

Recently, AWS introduced Strands Decider 2B, a lightweight decision model designed specifically for routing, classification, scoring, and orchestrating agent workflows.

Unlike traditional LLMs, Strands Decider doesn't generate arbitrary text. Instead, it selects from predefined options and provides confidence scores, making it ideal for Agentic AI and Multi-RAG systems.

In this article, I'll walk through how I installed and tested Strands Decider 2B locally on Windows using WSL2.

A common architecture today looks like this:

The problem?

The LLM is responsible for both:

A better approach is:

Now the LLM focuses on reasoning and generation, while the decision model handles routing and orchestration.

For this walkthrough I used:

Open PowerShell:

wsl -l -v

Example output:

NAME      STATE    VERSION
Ubuntu    Running  2

Launch Ubuntu:

wsl -d Ubuntu
mkdir -p /mnt/c/GENAI/strands

cd /mnt/c/GENAI/strands

Update Ubuntu:

sudo apt update

Install required dependencies:

sudo apt install -y \
 python3 \
 python3-pip \
 python3-venv \
 python3-dev \
 build-essential \
 gcc \
 g++

Create the environment:

python3 -m venv .venv

Activate it:

source .venv/bin/activate

Upgrade pip:

pip install --upgrade pip setuptools wheel
pip install strands-decider

Verify installation:

strands-decider --help

Install Hugging Face Hub:

pip install huggingface_hub

List available Strands models:

python -c "from huggingface_hub import list_models; [print(m.id) for m in list_models(search='strands')]"

The model used in this guide:

StrandsAgents/strands-decider-2B-hobson-v19

Launch the model:

strands-decider serve StrandsAgents/strands-decider-2B-hobson-v19 --device cpu

Expected output:

Application startup complete.
Uvicorn running on http://127.0.0.1:8000

The first startup downloads and caches the model automatically.

Open in your browser:

http://127.0.0.1:8000/docs

Or:

curl http://127.0.0.1:8000/openapi.json

Strands Decider supports three decision formats.

Choose one option from a list.

{
  "type": "choice",
  "instructions": "Select the best datasource.",
  "criteria": {
    "PLM": "Engineering changes and parts",
    "JIRA": "Issue tracking system",
    "CONFLUENCE": "Documentation repository",
    "UNKNOWN": "No suitable source"
  }
}

Yes / No decision.

{
  "type": "noul",
  "instructions": "Determine whether this statement is true."
}

Rate against an ordered scale.

{
  "type": "score",
  "instructions": "Rate the sentiment.",
  "criteria": [
    "Very Negative",
    "Negative",
    "Neutral",
    "Positive",
    "Very Positive"
  ]
}

Create a file called:

decider_demo.py
python
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:

python decider_demo.py

Sample output:

{
  "answers": {
    "datasource": {
      "choice": "PLM",
      "confidence": 0.94
    }
  }
}

One use case I was particularly interested in was reducing hallucinations across multiple RAG systems.

Routing logic becomes simple:

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 asking an LLM to guess which datasource to use, the decision model handles routing first.

I see strong potential in the following scenarios:

✅ Multi-RAG orchestration

✅ Agent tool selection

✅ Engineering Change workflows

✅ PLM assistants

✅ SharePoint routing

✅ Confluence routing

✅ Jira ticket management

✅ Intent classification

✅ Confidence-based validation

✅ Hallucination reduction

One of the biggest lessons I've learned building GenAI applications is:

Not every problem requires text generation.

Decision-making and text generation are fundamentally different tasks.

Using a decision model before retrieval and generation creates a much cleaner architecture:

 Decision Model
      ↓
  Retrieval
      ↓
     LLM

For enterprise AI systems, agentic workflows, and multi-RAG architectures, this pattern improves reliability, control, and observability.

If you're building AI agents today, I highly recommend experimenting with decision models as part of your architecture.

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

Ujjwalkumar Soni

Passionate about AI Agents, RAG Architectures, Knowledge Management, and Enterprise GenAI Solutions.

Let's connect and share ideas around Agentic AI and next-generation enterprise applications.

source & further reading

dev.to — original article How we check every AI-generated room render before a user sees it I built a handover board for the friend who was doing all the remembering Your agent's kill switch was never tested. That is the whole bug.