The number that matters landed quietly this week: Gemini 3.5 Flash-Lite is priced at $0.30 per million input tokens and $2.50 per million output — with batch mode halving that to $0.15 / $1.25 and a full 1M-token context window. That input rate is roughly one-third of GPT-5.6 Luna ($1 / $6) and Claude Haiku 4.5 ($1 / $5). If your agent makes a lot of small, dumb calls — and most agents do — Flash-Lite just reset the floor on what those calls should cost.
The honest answer to "is it cheap enough?" is: for grunt work, yes; for judgment, no. Here's how to tell the two apart before you rewire your stack.
The prices, side by side#
Three models compete for the "cheap tier that backs an agent" slot, and on raw input cost it isn't close — Flash-Lite is 3× under both rivals. Google positions it precisely for high-volume agentic tasks, translation, and simple data processing, and one write-up calls it the "purpose-built subagent tier." The at-a-glance table above is the whole comparison in four columns; the short version is that you pay Luna or Haiku a premium for reasoning discipline you often don't need on a grunt-work call.
What "grunt work" means for an agent#
Most of an agent's token spend is not the clever part. It's the plumbing:
- Formatting tool arguments from a loose instruction into a clean call.
- Extracting fields — pull the invoice number, the date, the status — from a blob of text a tool returned.
- Routing an intent to the right branch of your graph.
- Summarizing tool output so the next step (or the frontier model) gets a tight context instead of 8KB of JSON.
- Fan-out subagents, where the same simple task runs across dozens or hundreds of items in one run.
Every one of those is a call that needs to be correct and fast, not smart. That's the Flash-Lite lane. When the repetitive-call count is high, the 3× input discount compounds into the difference between a viable margin and a scary bill. We laid out the mechanics of splitting these calls in build a cost-aware model router for your agent.
Where the $0.30 tier bites#
Two failure modes are predictable enough to design around.
Multi-step reasoning. The moment a step has to hold a plan across turns — track constraints, notice a contradiction, decide what to do next — a lite model starts dropping things. The retries and the wrong turns erase the savings. Keep the planning step on a frontier model; the cost dial on that step (run high effort on the plan, low on the busywork) is the same lever we covered in reasoning effort vs. thinking budget.
Strict-schema tool calls. A subtly malformed argument — the right shape, the wrong field — passes JSON parsing and then corrupts state downstream, silently. This is where Haiku 4.5's tighter tool-use discipline earns its premium. If you send strict-schema tool calls to Flash-Lite, validate every argument before you act on it. A cheap call that quietly poisons your database is the most expensive call you'll make.
A cheap model that fails and retries is not cheap. Measure cost per completed task, not cost per token.
The decision#
Don't switch everything to the cheap tier — route. Send the plan and the multi-step reasoning to a strong model, fan the repetitive low-reasoning calls out to Flash-Lite, gate its tool output through validation, and track cost per completed task. Done that way, the $0.30 tier isn't a downgrade — it's the reason your fan-out step stops being the line item you're afraid to look at. If you're weighing it against the other budget backends, we ran the adjacent head-to-heads in GPT-5.6 Luna vs Gemini 3.6 Flash and Flash vs Haiku 4.5 vs GPT-5-mini as the cheapest workhorse.
