Tokens are the new pricing lever: Gemini 3.6 Flash math

Google released three Gemini models on 21 July: Gemini 3.6 Flash, Gemini 3.5 Flash-Lite and Gemini 3.5 Flash Cyber. The headline model, 3.6 Flash, keeps input pricing at $1.50 per million tokens and cuts output pricing from $9.00 to $7.50 per million. That is a 17% sticker reduction. The more interesting number sits next to it: Google says 3.6 Flash also uses roughly 17% fewer output tokens than 3.5 Flash to do the same work. Those two reductions compound. For an unchanged task, output spend drops by about 31%, roughly double what the price sheet suggests.

Most Swedish enterprise teams we work with run their production workloads on Azure OpenAI or through the Azure AI Foundry model catalog, not on Gemini. The release still matters to them, for one reason: it demonstrates that vendors now compete on token efficiency as much as on list price, and a cost comparison built on price-per-million-tokens alone will get the answer wrong. If your model evaluation spreadsheet has a column for output price and no column for tokens consumed per task, this release is the argument for fixing it.

What Google shipped on 21 July

Gemini 3.6 Flash: the workhorse gets cheaper twice

Gemini 3.6 Flash replaces 3.5 Flash as the default everyday model. Pricing lands at $1.50 per million input tokens and $7.50 per million output tokens, down from $9.00 output on 3.5 Flash. Google's stated benchmark movement is substantial for a point release: DeepSWE coding rises from 37% to 49%, MLE Bench from 49.7% to 63.9%, OSWorld-Verified computer use from 78.4% to 83%, and the GDPval-AA knowledge-work score from 1349 to 1421. The knowledge cutoff moves from January 2025 to March 2026, and the model retains the 1M-token context window. It shipped day one in the Gemini app, Google Antigravity, AI Studio and Android Studio, and GitHub enabled it in Copilot the same day.

Note what happened there. The model got measurably better at coding and agentic tasks while emitting fewer output tokens. Verbosity is not a proxy for quality, and the two can move in opposite directions in the same release.

Flash-Lite and Flash Cyber

Gemini 3.5 Flash-Lite is the cost floor of the family at $0.30 input and $2.50 output per million tokens, aimed at high-throughput, low-latency work such as agentic search. Google's published numbers show Terminal-Bench 2.1 at 54% against 31% for 3.1 Flash-Lite, SWE-Bench Pro at 54.2% against 49.6% for Gemini 3 Flash, and OSWorld-Verified at 74.0% against 65.1%. Gemini 3.5 Flash Cyber is the odd one out: a model fine-tuned for finding and fixing software vulnerabilities, restricted to governments and trusted partners under a pilot access program. It will not show up in your procurement options soon, but it signals where specialised model variants are heading.

The missing Pro, and Gemini 4

Gemini 3.5 Pro did not ship, despite being promised in May with a June target. Product lead Logan Kilpatrick said it is being tested with partners and should land soon. Google also confirmed it has started its most ambitious pre-training run yet, for Gemini 4. For planning purposes: the frontier tier is in flux, while the mid-tier Flash class is where the aggressive price and efficiency competition is happening right now.

Two levers move at once: price and verbosity

Your invoice for generative AI is, at its core, one multiplication: tokens consumed times price per token. Vendors have historically competed on the second factor, because it is the one printed on the pricing page. The first factor, how many tokens a model spends to complete your task, was treated as a fixed property of the workload. It is not. It is a property of the model, and Google just moved it deliberately.

Run the arithmetic on Google's own claims. A task that consumed T output tokens on 3.5 Flash consumes about 0.83T on 3.6 Flash, at a rate of $7.50 instead of $9.00 per million:

Output cost ratio = (new tokens / old tokens) x (new price / old price)
                  = 0.83 x (7.50 / 9.00)
                  = 0.83 x 0.833
                  = 0.69   -> ~31% lower output cost per task

Blended savings depend on your input-to-output ratio, since input stays at $1.50. As a worked illustration, not a benchmark: take a task with 5,000 input tokens and 2,000 output tokens. On 3.5 Flash it costs $0.0075 in input plus $0.0180 in output, $0.0255 total. On 3.6 Flash, input is unchanged and output falls to roughly 1,660 tokens at the lower rate, $0.0125. New total: about $0.0200, a 22% reduction on a task where the price sheet alone would have predicted less on the blended number. Input-heavy RAG workloads see less benefit; output-heavy generation and agentic workloads see more, because token efficiency compounds across every step of an agent loop where one step's output becomes the next step's input.

The uncomfortable implication: two models with identical list prices can differ meaningfully in real cost, and a model with a higher list price can be cheaper per completed task if it answers more concisely or needs fewer retries. Price sheets rank models; only measurement ranks costs.

Why this matters on Azure, where Gemini does not run

Azure-first teams consume GPT models through Azure OpenAI in Foundry Models, and increasingly Anthropic's Claude models through the Foundry catalog. Gemini is not part of that menu. So why care? Because the Flash release resets the external reference point your CFO and your procurement function will compare against, and because the same verbosity effect exists between the models you can deploy on Azure.

Different model families have consistently different output habits on identical prompts. Some default to long explanatory preambles, some pad code answers with restated requirements, some produce terse diffs. Reasoning-mode models add a further wrinkle: on several families, reasoning tokens are billed as output even when they never appear in the response you display. If you compared, say, a GPT model against a Claude model last quarter using list prices and a quality eval, but never logged completion tokens per task, your cost ranking may simply be wrong. A 20% verbosity difference is the same size as the entire Gemini price cut that made headlines this week.

The practical consequence: treat every vendor's per-million price as one input to a cost-per-task calculation you own, and make that calculation cheap to re-run, because this pricing news cycle now repeats every few months.

A decision framework: measuring cost per task, not per million

Here is the framework we use when a team asks whether to switch models or negotiate provisioned capacity. It takes roughly a sprint to stand up the first time and pays for itself on the first model comparison.

1. Define the task, not the request. A task is the unit your business cares about: one classified invoice, one drafted support reply, one merged pull request suggestion. An agent may spend fifteen model calls on one task. Cost per task is the metric; cost per call hides retries and loops.
2. Build a fixture set. 20 to 50 real, anonymised tasks per workload, with acceptance criteria. Without a quality gate, cost comparison rewards models that fail cheaply.
3. Log token usage on every call. The Azure OpenAI response includes prompt and completion token counts in its usage object; persist them with a task correlation ID. If traffic flows through Azure API Management, the token-metric emission policy can push per-model, per-consumer token counts into Application Insights without touching application code.
4. Compute the full formula. Cost per completed task = sum of (input tokens x input rate + output tokens x output rate + cached-input tokens x cached rate) across all calls in the task, including failed attempts, divided by tasks that passed acceptance. Include reasoning tokens where the model bills them.
5. Re-run on every model release. The fixture set makes this a one-day exercise. Vendors will keep moving both levers; your comparison must move with them.
6. Watch verbosity as a regression metric. Alert when median output tokens per task drifts upward after a model version bump or a prompt change. Token-efficiency regressions are silent cost increases, and in agent loops they compound.

Two cheap optimisations fall out of the same telemetry. First, prompt caching: cached input is discounted on every major platform, and the logs will show you which system prompts and RAG preambles are repeated often enough to matter. Second, model routing: once you know cost per task by workload, routing simple tasks to a Flash-Lite-class model on your own platform (GPT mini-class or Claude Haiku-class on Azure) becomes a data-driven decision instead of a hunch.

The Swedish and EU angle

Procurement should buy outcomes, not tokens. Swedish public-sector and enterprise procurement is comfortable specifying unit prices, and per-million-token rates look reassuringly like unit prices. They are not stable ones. A vendor can cut effective cost 31% in a week, or a model swap can raise your consumption without any price change. In an upphandling or a managed-service contract, specify cost per defined task with a quality threshold, require the supplier to expose token telemetry per task, and include a benchmarking clause that lets you re-price when the underlying model economics shift. A contract signed on July 2026 token prices will look mispriced within a year, in one direction or the other.

Budget forecasts need a token-efficiency line. Finance teams building 2027 AI budgets in SEK tend to model growth in request volume against flat unit costs. The Flash release shows both assumptions failing at once: unit prices fall, while agentic workloads multiply tokens per task. A better forecast models tasks per month, tokens per task by workload, and a price curve, each of which your telemetry from the framework above feeds directly. This also gives FinOps something concrete to review monthly instead of a single opaque Azure OpenAI line item.

Cheaper elsewhere is not deployable here. When a Gemini price cut lands, someone will ask why the team is not using it. For most Swedish regulated organisations the answer is unchanged by this release: the model runs on Google's cloud, and moving a workload there re-opens data residency review, GDPR Article 28 processor terms, network egress design and the security assessment your current Azure OpenAI deployment in Sweden Central or another EU region has already cleared. Cross-cloud model arbitrage has real switching costs. The right response to competitor price moves is usually not migration; it is using the public reference point to pressure-test your own per-task costs and, where relevant, your Microsoft negotiation.

Takeaways

Gemini 3.6 Flash cut output price 17% and output token consumption roughly 17%; the compound effect is about 31% lower output cost per task. The second lever never appears on a price sheet.
Rank models by cost per completed task on your own fixture set, with a quality gate. List price alone will misrank them.
Log prompt and completion tokens with a task correlation ID today; Azure OpenAI returns the numbers on every response, and APIM can emit them centrally.
Treat verbosity as a monitored regression metric, especially in agent loops where output feeds the next input.
Write token-price volatility into contracts and forecasts: benchmark clauses in procurement, a tokens-per-task line in the budget model.
Use competitor price cuts as negotiation and validation data, not as a migration trigger; residency and compliance reviews are part of the real switching cost.