The problem: premium models are quietly draining your AWS budget
Here's a pattern that shows up in almost every Bedrock account we look at: a team ships a generative AI feature, picks the most capable model available to be safe, and never revisits that decision. Six months later, the same frontier model is answering "what's my order status?" and "restructure our five-year loan/ debt strategy" with the exact same infrastructure and the exact same price tag.
That's the trap. Premium models like Claude Opus exist because some tasks genuinely need deep, multi-step reasoning — but most production traffic doesn't look like that. It looks like classification, short-form Q&A, intent detection, and templated responses: tasks a lightweight model handles just as well, at a fraction of the cost. When every request — simple or complex — gets routed to the same premium model, you're not paying for quality. You're paying for margin of safety you didn't need on 70-80% of your traffic.
The result shows up as a Bedrock invoice that keeps climbing even though your product hasn't materially changed. It's rarely one runaway workload — it's thousands of small, simple requests, each one paying premium rates it never needed.
The solution: Intelligent Prompt Routing as a smart traffic controller
Amazon Bedrock's Intelligent Prompt Routing solves this without asking you to write a single line of routing logic. Think of it as a traffic controller sitting in front of your model calls: every prompt that comes in gets evaluated for complexity, and Bedrock automatically forwards it to the model best suited to handle it — cheap and fast for simple requests, premium and thorough for the ones that actually need it. Your application talks to one endpoint. Bedrock decides, per request, which model answers it.
The pitch is simple: stop paying premium-model prices for basic-model work, without building or maintaining a custom classification layer to do it.
How it works: routing between model classes
Intelligent Prompt Routing operates on a paired model concept — you group models from the same family into a "low/mid" tier and a "premium" tier, and Bedrock's router predicts which one will give the best response for each incoming prompt.
Low/mid-tier models — fast, inexpensive, well-suited to classification, extraction, short-form Q&A, and routing-style tasks:
Amazon Nova Micro / Nova Lite
Claude Haiku
Meta Llama (8B/70B-class models)
Premium models — reserved for genuinely complex, high-stakes, multi-step reasoning:
Claude Opus
Amazon Nova Premier
Meta Llama 70B/90B-class models (for the Llama family pairing)
The mechanism itself works in four steps:
Prompt arrives at the router endpoint (a single ARN your application calls, instead of calling a specific model directly).
Complexity prediction — Bedrock analyzes the prompt's content and predicts how well each model in the pair would answer it.
Routing decision — Bedrock compares the predicted response quality of both models against your configured routing criteria (a response-quality-difference threshold) and picks a target.
Invocation and response — the selected model processes the request, and the response comes back through the same endpoint, with metadata telling you which model actually handled it.
Two flavors of router are available:
Default prompt routers — pre-configured, zero-setup routers Bedrock provides for each supported family. Good for evaluating the pattern before you commit to anything custom.
Configured (custom) prompt routers — you choose exactly two models from the same family and set your own routing-criteria threshold, trading off cost against quality precisely for your workload. Note that a router pairs exactly two models from the same family in the same AWS Region — it isn't a free-for-all across providers.
Cost comparison: standard vs. routed
The table below is an illustrative example — not a guarantee — based on published Bedrock on-demand rates, showing a workload of 100 million input tokens and 20 million output tokens per month, with roughly 80% of real-world traffic being simple/routine and 20% genuinely complex.
Rough math behind the routed estimate: Claude Haiku runs well under premium rates for both input and output tokens, so the ~80% of traffic it absorbs costs a small fraction of what the same volume would cost on Opus. The remaining ~20% of genuinely complex requests still go to Opus at full price, and Bedrock adds a small per-request routing fee on top. Even accounting for that fee, the blended bill typically lands well past the 50% savings mark — the exact number depends on your traffic mix, so treat this table as a model for your own math, not a fixed promise. A workload skewed more toward complex requests will save less; one skewed toward simple requests will save more.
Implementation steps: setting up your prompt router
Here's the step-by-step path to getting a router ARN and wiring it into your application. (See the accompanying console mockup image — illustrative, not a live screenshot, since generating one requires an active AWS session — showing the navigation and layout described below.)
Step 1 — Open the Bedrock console and find Prompt Routers
Sign in to the AWS Management Console, navigate to Amazon Bedrock, and in the left navigation pane look under the Tune (or Foundation models) section for Prompt routers.
Step 2 — Review the default routers
You'll land on a list of default prompt routers, one per supported model family (Anthropic, Meta, Amazon Nova). Select one — say, the Anthropic router — to see its paired models and try it in the Playground before committing to anything custom.
Step 3 — Configure a custom router (optional but recommended for production)
Choose Configure prompt router, give it a clear, meaningful name (you'll reference this in code), and select exactly two models from the same family — for example, Nova Lite andNova Pro. Set your routing criteria: a response-quality-difference threshold that controls how easily requests escalate to the premium model. A smaller threshold sends more traffic to the premium model; a larger one keeps more traffic on the cheaper model.
Step 4 — Copy the router ARN
Once your router is created, copy its ARN from the router's detail page. This ARN is what your application will call instead of a specific model ID — it's the single endpoint that all the routing logic sits behind.
Step 5 — Test in the Playground, then move to production
Before wiring this into your application, run a handful of representative prompts through the router in the Playground and check the routing metrics panel — it shows you which model handled each prompt, so you can sanity-check the routing behavior against your expectations before going live.
Step 6:- Verify basic and complex prompts actually route to different models
This is the step that proves the router is doing more than just always picking one model — and it's worth doing deliberately rather than trusting the first prompt you try. Run a small, mixed batch through the Playground and check the router-metrics icon on every response, not just a couple:
Nova Lite
Nova Pro
Conclusion: audit before you assume
If you haven't opened AWS Cost Explorer and filtered your Bedrock spend by model in the last month, that's the first move — not adding a router. Look at what's actually calling your premium model, and how much of that traffic is genuinely complex versus routine. In most accounts we've seen, a meaningful share of premium-model calls are answering questions a lightweight model would have handled just as well.
The challenge: open Cost Explorer this week, filter Bedrock usage by model ID, and ask honestly — how much of that spend is buying you quality you actually need, versus quality you defaulted into? For most teams, the answer is the difference between an invoice that keeps climbing and one that scales sensibly with real usage.
How Cloud.in can help
Setting up a prompt router is an afternoon's work. Getting the routing criteria, model pairing, and fallback behavior right for your traffic — without silently degrading quality on the requests that matter — is where most teams get stuck. That's the part Cloud.in specializes in: auditing your existing Bedrock (and broader AI infrastructure) spend, identifying where premium-model traffic can safely shift to lighter models, and implementing the routing, caching, and batching layers that make the savings durable rather than one-time.
Beyond prompt routing, we typically look at the same account for:
- Model distillation — training smaller, task-specific models on your own frontier-model outputs for high-volume, narrow tasks
- Prompt caching and context compression — cutting repeated-context costs on RAG and multi-turn conversation workloads
- Batch mode migration — shifting delay-tolerant workloads to discounted batch pricing
- Broader infra right-sizing — the same discipline applied to EC2, storage classes, and reserved capacity, so AI cost optimization isn't the only lever pulled
If your Bedrock bill has been climbing faster than your usage feels like it should justify, that's usually a sign there's a routing conversation worth having — reach out and we'll help you find out where.
Reference Architecture:-
The blog is written by Siddhi Bhilare, Cloud Consultant, Cloud.in
