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

> Source: <https://dev.to/ujjwalbsoni/running-aws-strands-decider-2b-locally-a-complete-setup-guide-for-ai-routing-multi-rag-systems-249c>
> Published: 2026-10-03 02:33:20+00:00

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
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](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.