At Tech86, we've seen companies burning six figures a month on premium models for tasks that a 42x cheaper model handles just as well. The problem isn't the model — it's the absence of economic criteria in selection. Model selection is unit economics, not fanboyism.
The numbers the market ignores
SWE-bench is the reference benchmark for coding capability. And the recent numbers are revealing. MiniMax M2.5 delivers 80.2% for $0.99 per million output tokens. Claude Opus 4.6 delivers 80.8% for $25 per million. The performance difference is 0.6%. The price difference is 42x.
On the input side, the gap is equally brutal: $0.118/M on MiniMax vs. $5/M on Opus. MiniMax also offers a 1M token context window vs. Opus's 200K. And it's open-source.
These aren't theoretical numbers. They're published prices, run benchmarks, declared specifications. When we put them in a spreadsheet, the conclusion is inevitable: for most code workloads, paying premium is misallocated capital.
What the benchmark doesn't tell you
SWE-bench measures one thing: ability to resolve issues from open-source repositories. It's useful as a reference, but it doesn't represent what happens in production. What MiniMax doesn't tell you: how many reasoning tokens does it burn per task? What's the real latency on complex code? Can the model maintain 1M tokens of context without degradation? Is the generated code actually comparable, or is it "syntax correct, logic broken"?
In our experience, benchmarks are the starting point, never the verdict. We've seen models with high SWE-bench scores that generate syntactically correct but logically broken code. We've seen models with lower benchmarks that deliver more robust code because they were trained on datasets more aligned with the client's domain.
SWE-bench doesn't measure code robustness, edge case handling, solution architecture, or readability and maintainability. These are the metrics that matter in production. And you can only evaluate them by testing on your real workload.
The silent waste: Opus for CRUD
If you're running Opus 4.6 to generate commodity code — CRUDs, simple APIs, automation scripts, data extraction — you're paying premium for something a 42x cheaper model does equally well or better. That's the reality nobody wants to admit.
We've audited AI operations where 80% of requests were commodity tasks running on premium models. The monthly cost was 5x higher than it needed to be. And quality didn't improve — because for CRUD and boilerplate, any model with 75%+ on SWE-bench delivers the same result.
Now, if you need deep reasoning on architecture, massive context windows for monorepos, agentic behavior with complex tool calling, or enterprise-grade safety and alignment — Opus may still justify the cost. The question is: how many of your requests actually need that?
The real cost per task (and why nobody calculates it)
Price per million tokens is just the surface. The real cost of a task includes input tokens, output tokens, and reasoning tokens. A model that costs 42x less per token but burns 3x more reasoning tokens might not be as cheap as it seems.
In practice, we've found the calculation is more nuanced. Premium models tend to be more reasoning-efficient — they reach the answer with fewer intermediate tokens. Cheaper models may compensate for lower per-token pricing with more reasoning overhead. Cost per completed task is what matters, not price per token.
Our process: run the same workload across multiple models, measure total tokens consumed (input + reasoning + output), multiply by price, and compare cost per task. In 7 out of 10 code use cases, the cheaper model wins even accounting for reasoning overhead.
Model routing: the architecture that separates amateur from professional
Model routing is the practice of directing each request to the most appropriate model based on task complexity. Simple tasks go to high-throughput, low-cost models. Complex tasks go to premium models. It's the same logic as using a sedan for your daily commute and a truck for moving day.
At Tech86, we implement model routing based on complexity classification. The system analyzes the prompt, classifies the task as commodity or complex, and routes it to the correct model. The result: 60-70% reduction in inference cost with no loss in final output quality.
The market is redefining what "frontier" means. It's no longer defined by who has the highest benchmark. It's defined by who delivers the most throughput per dollar. And model routing is the tool that turns this redefinition into real savings.
FinOps for AI is not optional
If your use case runs at 80% of what the model offers, paying 42x more is capital waste. Period. No "brand" or "trust" argument justifies burning infrastructure budget on oversized models.
FinOps for AI is the process of ensuring every dollar spent on inference generates proportional value. That means mapping use cases, measuring cost per task, implementing model routing, and continuously reviewing. The LLM market shifts every week — the model that was premium last month may be commodity today.
At Tech86, we design AI architectures with model routing based on complexity and real cost. If you're running the most expensive model because "it's always been that way," it's time to recalculate. AI FinOps consulting isn't a cost — it's ROI.