# Amazon Replaces Claude Sonnet 4.6 With Strands Decider on Internal Tickets

> Source: <https://explainx.ai/blog/amazon-strands-decider-internal-ticketing-sonnet-replacement-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-10 00:00:00+00:00

**Amazon engineers replaced Claude Sonnet 4.6 with Strands Decider E4B** for labeling internal support tickets — cutting modeled cost from about **$22,200 to $500 per million tickets** at published list prices, according to the [Strands Agents team write-up](https://strandsagents.com/blog/amazon-saves-millions-replacing-sonnet-with-strands-decider/?ref=explainx) dated November 9, 2026 that reached the [Hacker News front page](https://news.ycombinator.com/item?id=50436640&ref=explainx) the following day.**

This is the clearest public teardown yet of **when to fire a frontier LLM** and ship a **tiny decision head** instead.

## TL;DR

| Metric | Sonnet 4.6 (reported) | Strands Decider E4B | 
|---|---|---|
| Avg latency | 4,215 ms | 897 ms | 
| Input tokens / ticket | 6,554 | 2,009 | 
| Output tokens / ticket | 170 | 1 | 
| Cost / million tickets (list) | ~$22,200 | ~$500 | 
| Task | Multi-class ticket labels | Same fixed catalog | 

## Problem shape: closed catalog at huge volume

Amazon Strands Decider cut internal ticket labeling cost versus Claude Sonnet 4.6

Internal ticketing systems classify each ticket into **known categories** — routing, prioritization, SLA rules. That is structurally **multi-class classification**, not open-ended chat.

Sonnet 4.6 worked when Amazon needed a quick solution: strong JSON obedience, decent reasoning, available on Bedrock. But every ticket paid for **thousands of input tokens** and **hundreds of output tokens** because the model generates language, not just a label index.

Strands Decider flips the contract:

- Inputs describe ticket state.
- Outputs are **scores over a fixed catalog** (about 20 categories in the blog's example).
- No marketing prose, no chain-of-thought essay — **one decision** .

That's the same design pattern we teach for [semantic caching and routing](https://explainx.ai/blog/semantic-caching-llm-apps-cost-latency-guide-2026), taken to its logical extreme.

## Rollout: DUAL mode before cutover

Amazon did not blind-switch. The blog describes modes:

- **DUAL** — Sonnet and Decider run in parallel; Sonnet labels remain authoritative while teams compare.
- **DECIDER** — full traffic on the small model after parity looked good.

That is the enterprise version of **shadow deployments** in traditional ML. Agent teams should copy it before any [Bedrock tokenomics refactor](https://explainx.ai/blog/amazon-bedrock-tokenomics-data-lake-finops-2026).

## Infrastructure and pricing math

Decider E4B (a LoRA adapter and readout head on Google's Gemma 4 E4B, per its [Hugging Face model card](https://huggingface.co/StrandsAgents/strands-decider-E4B-gemma4-v1-2610?ref=explainx)) serves on **SageMaker** `ml.g5.xlarge` (NVIDIA A10G). Sonnet stays on **Bedrock global endpoints** at list **$3 / $15 per million** input/output tokens.

The blog's table (reproduced conceptually):

|  | Sonnet 4.6 | Decider E4B | 
|---|---|---|
| Billing model | Per token | Per GPU hour | 
| Per-ticket cost (derived) | ~$0.0222 | ~$0.0005 | 
| Per-million tickets | ~$22,200 | ~$500 | 

Decider's per-ticket cost **depends on utilization**. At ~640 ms per request, one instance might handle ~5,600 tickets/hour; the blog assumes headroom for bursts, landing near **$500/million** in practice.

We have not independently rerun Amazon's quality evaluators. Treat accuracy claims as **Amazon's report**, not a third-party benchmark.

## What developers are saying

On [HN item 50436640](https://news.ycombinator.com/item?id=50436640&ref=explainx), commenters treated the post as a **production routing** story, not a model-brand fight.

**Kaedon** [asked whether the cited per-million savings imply on the order of tens of millions of internal tickets per year](https://news.ycombinator.com/item?id=50436881&ref=explainx) once alarms and security routing are included — scaling math, not a verified Amazon volume figure.

**Gasp0de** [said the Gemma-based E4B build versus the earlier 2B Strands Decider trial was easy to misread](https://news.ycombinator.com/item?id=50437514&ref=explainx) and wondered why the shipped endpoint is still branded Strands Decider.

**psnehanshu** [questioned why Sonnet was the starting point](https://news.ycombinator.com/item?id=50437307&ref=explainx) instead of a smaller chat model — a fair prompt to audit historical routing choices before copying the pattern.

None of these threads settle quality parity; they show developers stress-testing **volume, naming, and baseline model choice** when a decision head replaces a frontier LLM.

## When to copy Amazon's pattern

Routing high-volume tickets to a small decision model instead of a frontier LLM

| Signal | Route to Decider-style model | Stay on frontier LLM | 
|---|---|---|
| Label set | Fixed enum < 100 classes | Free-text replies | 
| Volume | Millions / month | Thousands | 
| Risk | Misroute ticket (recoverable) | Customer-facing prose | 
| Change frequency | Quarterly taxonomy updates | Daily new intents | 
| Explainability | Logit scores suffice | Need cited paragraphs | 

Pair with [Claude Sonnet cache pricing](https://explainx.ai/blog/claude-sonnet-5-5-cache-read-price-cut-0-10-agentic-cost-math-2026) math — caching helps Sonnet, but cannot beat a 44x structural cost gap when outputs are one token.

## AWS and Anthropic context

Amazon helped build Anthropic, but **finops pressure** is real. Separate outlets reported Amazon hunting cheaper models as contracts shift toward token billing. This blog is evidence Amazon **will ship internal replacements** where economics demand it, regardless of partnership press releases.

For builders on **Bedrock**, the lesson is to architect **pluggable decision stages** in agent graphs — a pattern [AWS Bedrock AgentCore layers](https://explainx.ai/blog/aws-pluggable-agentic-ai-framework-bedrock-agentcore-seven-layers-2026) already encourage.

## Implementation checklist

1. **Instrument token counts per task type** in your agent — if p95 input is 5k tokens for a label, you are a candidate for specialization.
2. **Freeze a golden ticket set** with human labels.
3. **Train or host a decision endpoint** (SageMaker, self-hosted Gemma, or your own linear head on embeddings).
4. **Run DUAL** until mismatch rate is below your routing SLO.
5. **Keep Sonnet on the long tail** — novel tickets still benefit from generative reasoning.

## Token math worked example (per the Strands blog)

Using Amazon's published token splits for **one ticket**:

| Step | Sonnet 4.6 | Decider E4B | 
|---|---|---|
| Input tokens | 6,554 | 2,009 | 
| Output tokens | 170 | 1 | 
| Bedrock list price components | $3 input / $15 output per M | n/a (GPU hour) | 

Input cost Sonnet ≈ 6.554 × $3/M ≈ **$0.0197**. Output ≈ 170 × $15/M ≈ **$0.00255**. Total ≈ **$0.0222** per ticket — matching the blog.

Decider swaps token bills for **amortized GPU seconds** at ~897 ms per call. At ~5,600 tickets/hour/instance, the blog lands near **$500 per million tickets** after burst headroom — **44× cheaper** than Sonnet at list.

Your org's **Enterprise Discount Program** on Bedrock changes the Sonnet side; **Savings Plans** change GPU side. Recompute before pitching leadership.

## Architecture diagram in prose

Tickets flow: **feature extractor → Strands Decider endpoint → label choice → router**. An optional **Sonnet shadow path** runs in parallel during DUAL mode before cutover.

Sonnet path adds **chain-of-thought tokens** you do not need when the downstream system only consumes an **enum**. Removing free-text generation is the savings lever, not squeezing prompt engineering on the same model family.

## Monitoring after cutover

Track these weekly:

| Metric | Healthy signal | Investigate if | 
|---|---|---|
| Label mismatch vs golden set | Under agreed threshold | Spikes after taxonomy edit | 
| p99 latency | Near Decider SLA | Approaches old Sonnet tail | 
| "Other/unknown" bucket rate | Flat | Rises (novel ticket types) | 
| Human overrides | Stable | Climbs after cutover | 
| GPU utilization | 60–80% | Sustained peg at 100% | 

Feed overrides back into **DUAL** shadow runs before the next retrain.

## Relationship to Strands Agents open tooling

The post lives on **strandsagents.com**, AWS's agent framework site. Even if you are not Amazon, the pattern is portable:

- Export labeled tickets.
- Fine-tune or distill a **small classifier** .
- Host on **SageMaker** or any GPU service.
- Keep Sonnet on the **escalation queue** only.

See also [AWS Quick Skills catalog](https://explainx.ai/blog/aws-quick-skills-agents-catalog-build-guide-2026) for how Amazon productizes repeatable agent templates — internal Decider is the extreme version of templating.

## What people are asking

**Is 2B enough?** Amazon moved from a 2B Decider trial to **Gemma-based E4B** when evals demanded it. Size is empirical.

**Can I buy Strands Decider on Marketplace?** The blog documents **Amazon internal** deployment; public SKUs may lag. Watch re:Invent channels.

**Does this hurt Anthropic revenue at Amazon?** Likely on this **one workload**. Bedrock still runs plenty of Sonnet elsewhere in the company.

## FinOps template you can copy

| Field | Sonnet baseline | After Decider | 
|---|---|---|
| Monthly ticket volume | 1.0M (example) | 1.0M | 
| Cost per million (list) | $22,200 | $500 | 
| Monthly inference spend | $22,200 | $500 | 
| GPU ops overhead | $0 | add SRE hours | 
| Break-even if GPU ops | n/a | still wins above ~10k tickets/mo at these list prices | 

Plug your real volumes into the Strands table before presenting to finance. Include **human review hours** saved from faster labels — latency dropped **78%** in their report.

## Security note

Ticket bodies contain **PII and credentials**. Moving from Bedrock Sonnet to a self-hosted Decider endpoint shifts **data residency** to your VPC — good for compliance, but it concentrates breach impact. Lock down the **SageMaker endpoint** with IAM, VPC-only access, and logging equivalent to what you required from Anthropic.

Agents that relabel tickets are still **agents**; apply least-privilege tool access even when the model is only two billion parameters.

## Where this does not apply

Skip the Decider pattern when:

- Labels require **free-text customer communication** .
- Taxonomy changes **weekly** from product launches.
- Errors are **highly asymmetric** (medical triage, security escalation).
- You need **citations** in the output for auditors.

Those paths still belong on frontier models or human teams — just route with a **cheap classifier gate** first so Sonnet only sees the ambiguous tail.

Schedule quarterly taxonomy reviews so your enum stays stable enough to justify the specialized endpoint.

Publish a short **runbook** now for on-call when mismatch rates spike so engineers know whether to roll back to DUAL mode or widen the catalog.

## Bottom line

Amazon's Strands Decider rollout is a **production case study** in specialized models beating general LLMs on cost **without** changing the business outcome. If your agent pipeline treats every step as a chat completion, you are overpaying.

Read the [Strands Agents post](https://strandsagents.com/blog/amazon-saves-millions-replacing-sonnet-with-strands-decider/?ref=explainx) for token tables and deployment notes, then audit your highest-volume tool calls.

## Related reading

*Cost figures use list prices cited by Strands Agents on November 10, 2026; your Bedrock discounts and GPU utilization will differ.*