Cheap-tier model choice gets less scrutiny than flagship choice, which is backwards: this tier usually carries the most calls per day. The specs here point one way and our experience points another, so this page separates the two.
What do the specs say?
They say buy Flash. Gemini 3 Flash costs $0.50/Mtok in and $3/Mtok out against Haiku 4.5's $1 and $5. Its context window is 1M tokens against Haiku's 200K. It takes video, audio, images, PDFs, and text as input; Haiku takes text, images, and PDFs. Both support reasoning and tool calling.
Monthly, on 1M input plus 200K output per day: Flash about $33, Haiku about $60. Nearly half price, five times the context, more modalities. On paper this is not a contest.
Why would anyone pay double for Haiku?
Because at this tier the binding constraint usually isn't capability, it's consistency under automation. Cheap-tier calls live inside loops: classify this ticket, extract these fields, route this request, summarize this chunk, thousands of times a day, with output feeding code rather than humans. What matters is the malformed-output rate, because every malformed response is a retry, a fallback, or a silent data bug.
In our experience, Haiku 4.5 is the more predictable worker in exactly that setting. It inherits Claude's tool-calling discipline, holds JSON schemas more reliably under pressure, and punches above its price class on small coding tasks. Whether that's worth 2x depends entirely on what a failure costs you downstream.
One more consideration: Flash carries a preview label, and preview pricing and behavior can shift on the way to GA. For a tier you're wiring deep into automation, that churn risk is worth weighing.
Where does Flash win outright?
Two places where there's no real debate. Media pipelines: if your cheap tier touches audio or video, transcription, call processing, screen-recording analysis, Flash handles it natively and Haiku simply can't. And long-context batch work: Flash's 1M window lets you process entire documents or codebases in single calls that Haiku's 200K window would force you to chunk, and chunking logic is a permanent tax on your pipeline.
What's the right way to test this tier?
Don't benchmark on quality rubrics; benchmark on failure rate. Take a day of real traffic, run it through both models, and count schema violations, refusals, and outputs your parser rejected. Multiply your retry cost by that rate and add it to the token bill. At this tier, the model with the lower all-in cost per successful call wins, and that's frequently not the one with the cheaper list price.