Most products that put a model behind a chat surface in 2026 reach for the smartest available frontier model. Cambio runs on Gemini 2.5 Flash Lite. Here is the actual engineering tradeoff that led to that choice — including the period we spent on a different fast-tier model first — and the conditions that would make us change our mind again.
When you put a language model behind a product surface, the loudest default is to reach for whichever frontier model tops the leaderboard that month. Smarter is better, the reasoning goes, and the cost difference disappears at scale.
Cambio runs on Gemini 2.5 Flash Lite — Google's fast tier, not its reasoning tier. That has been the production default since 27 May 2026; before it, the same layer ran on xAI's grok-4-1-fast. This post is the engineering reasoning behind the current choice, and the conditions that would make us revisit it again.
What the model has to do at Cambio
Two jobs, both bounded. Neither is reasoning-heavy.
The first is parsing. The model takes a short user message and returns one JSON object: an intent from a fixed list, seven entity fields — from-currency, from-network, to-currency, to-network, amount, direction, preference — and a confidence number. It is not the first thing to see the message: a deterministic resolver handles most turns on its own, and the model is consulted when that resolver is uncertain. On a sample of 209 production turns, the deterministic layer answered 69% alone and the model was reached on 8%.
The second is narration. The model receives a structured quote object and writes a short line of plain language around it. It may not write a price, a rate or an amount — the card carries every number, and the model is never handed the job of producing one. Where it adds a phrasing clause, the code caps that clause at twelve words and discards anything longer.
Neither job involves multi-step reasoning. Neither job requires the model to choose between many alternatives. Neither job has the model interacting with tools, calling APIs, or holding state across turns. The capability requirements are: read a short prompt, follow a structured output format, produce coherent English. Every modern language model can do this, including ones launched two or three years ago.
Why frontier reasoning models are the wrong tool here
We did not run a head-to-head benchmark of the frontier models against this workload, and we are not going to publish one we did not run. The choice did not need one. The question was never which model is most capable; it was which model is fast enough, cheap enough and disciplined enough about structured output for two jobs that deterministic code already handles most of the time.
What we did measure is our own system. A classification call is about 70 input tokens and 30 output tokens — on the order of $0.0001 per uncached prompt at list prices, probed against Flash Lite on 26 May 2026 — and a repeated prompt is served from cache without reaching the model at all. On latency, the deterministic path averages about 1.1 seconds end to end and the path that calls the model about 2.3. That gap, not a leaderboard, is what the model choice has to answer to.
Past a certain point, more capability is wasted budget. Once a model is fast enough and right enough for a bounded job, the experience is dominated by latency rather than by the model's ceiling.
Why the fast tier in general
The shortlist is the fast tier of the providers our agent layer supports: Gemini 2.5 Flash Lite, which runs it today; grok-4-1-fast, which ran it before; and GPT-5 Mini, which stays selectable. Each of them can read a short prompt, follow a schema and write a sentence. At our volume, each of them costs little enough that price alone does not decide it.
So the decision is about operational fit rather than capability: what a call costs at the volume we actually run, how reliably the model returns the exact object our schema asks for, how it behaves when a provider is busy, and how easy that provider is to live with day to day.
Why Gemini 2.5 Flash Lite specifically
On cost: our prompts are short in and short out, which is the shape the fast tier prices best. At roughly 70 tokens in and 30 out, a call costs on the order of $0.0001 at list prices, and a repeated prompt never reaches the model at all because the classification is cached. We are not publishing a price ranking of the three, because we have not run one that would survive scrutiny.
On structured output: we do not ask for free text and hope. The call pins the response type to JSON, hands Google a response schema with the required fields and enums spelled out, and runs at temperature zero. Anything that comes back and does not fit the schema is discarded and the turn falls back to deterministic handling — so a malformed output costs a retry, never a wrong card.
On failure behaviour: the layer takes an ordered list of providers, Gemini then xAI by default, and silently skips any that is not configured. If every configured provider fails, the turn returns a safe fallback shape instead of blocking the customer. A model outage is a slower answer, not a dead composer.
On the prior production run: the first version of Cambio ran this layer on grok-4-1-fast. The switch to Flash Lite on 27 May 2026 was not about Grok being wrong. The agent layer is provider-agnostic — xAI and OpenAI are still selectable through a single environment variable — so the choice stays reversible.
Why not the reasoning variant
Gemini 2.5 ships a thinking-mode variant. We do not use it. Thinking mode is designed for problems that benefit from chain-of-thought — multi-step problems, problems where the model has to consider alternatives, problems where intermediate scratch-pad steps improve the final answer.
Neither of our two jobs is that. Turning a short message into one JSON object does not benefit from a reasoning step, and neither does writing one sentence around a quote the code has already computed. So the call sets a thinking budget of zero. The comment in our own classifier puts it plainly: we don't need chain-of-thought for single-shot classification.
That setting lives in the code rather than in anyone's head, and it applies to every call this layer makes. It is the kind of default worth writing down: reasoning you do not need is latency you pay for on every single turn.
What we are giving up
Honest disclosure of the trade-off. By not reaching for a frontier model we give up the margin on the most ambiguous messages: someone who types something genuinely confusing may get a weaker clarifying question than a larger model would produce. We also give up capabilities the frontier tier sells — very long context windows, long tool-calling chains, deep multimodal reasoning — none of which our two jobs use, and all of which would matter if we widened the model's scope. We won't, per the previous post in this series.
What we are not giving up: the deterministic path, which answers most turns without a model at all; the rule that every number on the card is computed by code and never written by the model; and the ability to change provider in one line if the trade stops making sense.
When we would revisit
A few specific conditions would make us reopen the model selection again.
If Flash Lite's latency degrades materially and stays degraded, the budget breaks and we switch. We watch the latency of our own composer rather than a vendor's published figure, because that is the number a customer actually feels.
If quality drops in a specific language, we can route that language elsewhere. The assistant already answers in nine languages, and the layer takes an ordered provider list, so that is configuration rather than a rewrite.
If pricing changes substantially — say Google raises Flash Lite rates 5x or a competitor cuts to a tenth — we revisit the cost axis. We will not switch for a 10% pricing difference, but a structural shift matters.
If a newer fast-tier model does better on our own prompts — the ones customers actually type, not a public leaderboard — we switch. That is how this layer arrived at Gemini in the first place.
The general lesson
Choosing a model is a workload-specific decision, not a brand decision. The "best" model for a product depends on the shape of the prompts you are sending, the latency budget you have, the structured-output discipline you need, the cost envelope at your scale, and the provider posture you can live with. None of those things are visible in a leaderboard. All of them have to be measured against your actual workload — and re-measured periodically, because providers ship new fast-tier models every few months and the answer can move.
For Cambio's shape — short symmetric prompts, hard latency budget, two narrow jobs that do not need reasoning — Gemini 2.5 Flash Lite is the right answer today. For a different product with a different shape, the right answer is genuinely different. If you are building anything similar, the takeaway is not "use Gemini Flash Lite." It is "build a provider-agnostic agent layer, test the fast tier against your actual workload, and re-run the test every quarter."
The final post in this series goes deeper than any so far: how cross-chain swaps on Cambio work without bridge contracts, and why that is a different operational profile from the architectures much of the industry uses for the same job.
