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 dated November 9, 2026 that reached the Hacker News front page 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, 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.
Infrastructure and pricing math #
Decider E4B (a LoRA adapter and readout head on Google's Gemma 4 E4B, per its Hugging Face model card) 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, 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 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 and wondered why the shipped endpoint is still branded Strands Decider.
psnehanshu questioned why Sonnet was the starting point 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 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 already encourage.
Implementation checklist #
- Instrument token counts per task type in your agent — if p95 input is 5k tokens for a label, you are a candidate for specialization.
- Freeze a golden ticket set with human labels.
- Train or host a decision endpoint (SageMaker, self-hosted Gemma, or your own linear head on embeddings).
- Run DUAL until mismatch rate is below your routing SLO.
- 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 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 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.