How I Cut My LLM Bill 79% in 15 Minutes Without Changing Application Code

Most developers pick one LLM at the start of a project, put it in the config, and never revisit it. I did the same thing. Then I ran an experiment that made me feel kind of stupid.

TLDR:

-> I ran 29 identical prompts through Claude Opus 4.7 and 3 cheaper specialist models. Total cost: $0.31 on Opus vs. $0.06 with routing. 79% savings.
-> Classification tasks were 23.8x cheaper on GPT-5.4 Mini. 29/29 prompts produced equivalent output.
-> Coding tasks were 5.8x cheaper on DeepSeek V4 Pro. But 3x slower. Use for batch jobs, not live endpoints.
-> Creative tasks saved 65% on Claude Sonnet 4.6 vs. Opus. -> The fix: an LLM gateway that routes by task category. One endpoint, 15-minute setup, no code changes beyond swapping the base URL.
-> Don't set your default routing category to the cheapest model. Ambiguous prompts land there.
-> Don't use Lowest Price routing on user-facing endpoints. Latency kills UX.

I was running Claude Opus 4.7 on everything. Classification? Opus. Extracting a name from an email? Opus. Formatting a JSON response? Opus.

I didn't set it up this way on purpose. I picked a model early, it worked, I moved on. If you're shipping an LLM-powered product right now, you've probably done the same thing.

Here's what that costs.

The experiment

I wrote a Python script that sends 29 prompts to Claude Opus 4.7, then sends the same 29 prompts to cheaper models matched by task type.

Classification and extraction went to GPT-5.4 Mini ($0.75/M input, $4.50/M output). Coding tasks went to DeepSeek V4 Pro ($2.10/M input, $4.40/M output). Creative work went to Claude Sonnet 4.6 ($3.00/M input, $15.00/M output).

The baseline for everything was Opus ($5.00/M input, $25.00/M output).

Results:

Classification (10 prompts): $0.0317 on Opus vs. $0.0013 on GPT-5.4 Mini. 95.8% cheaper. That's 23.8x less for ticket categorization, sentiment detection, intent classification, language detection, PII checks. All 10 produced the same correct answer. The cheap model was actually cleaner -- it returned the label without a 3-paragraph explanation.

Extraction (5 prompts): $0.0239 on Opus vs. $0.0042 on GPT-5.4 Mini. 82.4% cheaper. Structured data from free text, invoice parsing, date extraction, contact info parsing. Same results.

Coding (7 prompts): $0.1652 on Opus vs. $0.0285 on DeepSeek V4 Pro. 82.7% cheaper. LRU caches, rate limiters, async fetchers, retry decorators, refactoring. DeepSeek produced clean code.

Creative (7 prompts): $0.0880 on Opus vs. $0.0307 on Sonnet 4.6. 65.1% cheaper. Product emails, blog openings, Twitter threads, cold outreach, changelogs.

Total across all 29 prompts: $0.31 on Opus. $0.06 with routing. 79% less.

Same prompts. 29 out of 29 produced equivalent output. 4.8x cost difference. I was paying Opus pricing to classify support tickets.

Why nobody fixes this

The answer is obvious: use cheap models for simple tasks, expensive models for hard ones. Everybody knows this. Almost nobody does it.

Because doing it manually is real work. You'd need to build a classifier for task type, maintain separate API integrations per provider, handle auth and failover for each, track costs across multiple dashboards, and update the routing every time you add a model or task type.

That's 2-3 weeks of infrastructure work. Then you maintain it forever.

So the rational move is eating the cost. One model, one integration, ship the feature. I get it. That's what I did too.

The 15-minute fix

I used an LLM gateway called FastRouter to automate the routing. The math works with any gateway that supports category-based routing, but here's what my setup looked like.

You create what's called a Virtual Model Alias. It's one name that maps to multiple models behind the scenes. You pick which model handles which type of task: classification goes to the cheap one, coding goes to the strong one, creative goes to the quality one. When a request comes in, the gateway detects the task type and routes it automatically. Your application just talks to one endpoint. It doesn't know or care which model is doing the work.

The setup is a dashboard, not code. Create an account at fastrouter.ai (add some credits), generate an API key, go to Virtual Models, pick your models, assign them to categories, and swap one URL in your app config. That's the whole thing.

One important detail: set your default category to a strong general-purpose model, not the cheapest one. Ambiguous prompts (half code, half explanation) land in the default bucket. If your default is a $0.75 model, those ambiguous tasks get weak answers.

Total setup: about 15 minutes.

The model-to-task cheat sheet

Save this if you're planning to optimize LLM costs this quarter.

Use GPT-5.4 Mini ($0.75/$4.50) for:
-> Classifying tickets, emails, or intents -> Extracting structured data from free text -> Sentiment and language detection -> PII identification -> Any task where the output is a label, a category, or a short JSON object

Use DeepSeek V4 Pro ($2.10/$4.40) for:
-> Algorithmic coding problems -> Code refactoring and utility functions -> Batch code generation -> Skip for user-facing endpoints (averaged 37s per prompt in my test)

Use Claude Sonnet 4.6 ($3.00/$15.00) for:
-> Marketing copy, blog posts, email drafts -> Creative rewriting and tone work -> Changelogs, product launch emails -> Anything where voice matters

Keep Opus or GPT-5.4 ($5.00+/$15.00+) for:
-> Multi-step architectural reasoning -> Complex analysis where model quality changes the output -> Your default bucket for ambiguous prompts

What to watch out for

DeepSeek V4 Pro is slow for real-time use. It averaged 36.9 seconds per coding prompt in my test. Opus did the same work in 11.3 seconds. Use DeepSeek for background jobs and batch processing. Don't put it behind a user-facing endpoint unless your users have patience.

The "79% savings" number assumes you're currently running everything through a frontier model. If you're already using GPT-5.4 Mini for simple tasks, your gap will be smaller. This experiment specifically measures "one expensive model for everything" vs. "right model per task."

Creative routing saves less than classification routing. Sonnet saved 65% vs. Opus on creative work. Classification saved 96%. Your actual ROI depends on your traffic mix. If 80% of your calls are creative, routing helps less.

I ran 29 prompts, not 29,000. Before routing production traffic, test your actual prompts in the playground side by side. The cost of math works. Whether the output quality meets your specific bar is something only you can verify.

Routing a bad prompt to a cheaper model gives you bad output faster and cheaper. It doesn't fix the prompt. Spend an afternoon testing which models perform well on your actual prompts before you set up the routing.

The scale-up math

For a team making 10,000 API calls per day where 50% are simple tasks:

Running everything through Opus: roughly $6,000-8,000/month in LLM costs. Routing simple tasks to GPT-5.4 Mini and keeping complex tasks on Opus: roughly $2,000-4,000/month.

That's $24,000-48,000/year. Enough to fund a junior engineer. Or a lot of compute for the features that actually need a frontier model.

Troubleshooting

"Response times spiked on a user-facing endpoint." You're probably using Lowest Price routing on that category. Switch to Priority Routing for anything latency-sensitive.

"Output quality dropped on a specific task type." The task is probably ambiguous. These fall to your default category. Make sure your default is a capable model.

"A provider went down." That's the point. FastRouter fails over to the next model in your alias. You'll see a small cost bump on rerouted requests in the dashboard. Your app stays up.

2026 is going to be a different game for teams who match models to tasks vs. teams who keep running Opus on everything. The pricing gap between frontier and lightweight models is 5-24x right now. It's widening every quarter.

A team making 50,000 API calls a day where half are simple tasks is paying an extra $5,000-10,000 per month for output quality they can't tell apart. That's a tax on every feature you ship. The teams that figure out routing this year stop paying it.