Use one model per job: a strong model to plan and build, a small one for fully specified edits, an image model for images, and a backup from another provider. One model for everything means flagship prices for label changes or a weak model building your app.
This guide is for founders and teams adding AI to a product, and for GrowApps users who wonder which model handles their request. It describes how our builder routes work as of October 2026.
In short:
- Prompt length did not predict effort across 689 requests we analysed.
- Cheap lanes need a rule that sends hard cases back.
- Apps should name the kind of request and let the server pick the model.
- Model tests must pin every turn to one model.
Jobs differ more than prompts suggest
The size of a request is a bad guide to the size of the job. We analysed 689 past build and edit requests and found that prompt length told us almost nothing about effort.
A one-word "continue" could trigger more than 70 tool calls, because it resumed heavy work in progress. Long pasted error logs and detailed specs often needed far less work than their length suggested. Context decides the job, not word count.
The cheap end is real, though. About a quarter of completed edits were small turns: a copy tweak, a retry nudge, a quick question. Those are the turns a smaller model should take.
A routing table for an app builder
Each job gets the cheapest model that does it well, and only that job. This is how GrowApps routes work today:
| Job | Model | Why |
|---|---|---|
| Planning and building | Gemini 3.8 Flash | Must invent structure |
| Fixed text edit | Smaller, cheaper model | Fully specified |
| Computed or translated text | Gemini 3.8 Flash | Needs reasoning |
| Summarising long sessions | The model that ran the turn | Rereads at the cached rate |
| Logos and images | Dedicated image models | Text models cannot draw |
| Overloaded main model | Another provider's model | Avoids a shared outage |
These lanes are hand-set rules, not a learned router. Each one exists because a measurement or an incident showed the default was wrong for that job.
One session can use more than one model
Follow one session for a barbershop booking app. The first build, with screens, booking rules and data, runs on the main model.
Then you click the button "Book" in the preview and type "Reserve". Usually that is patched straight into the code with no model at all. If the patch cannot apply, the edit goes to the smaller model.
Next you edit "3 slots left", which is computed from the schedule, so it goes to the main model. Once the conversation grows very long, the same model summarises it at the end of a turn. Doing it then reuses the provider's warm cache, and the next turn starts lighter.
Cheap lanes need an escape hatch
A cheap lane fails quietly on the cases that only look simple. Our text-edit lane shows why.
Most edits made in the preview's text editor are plain: "change Book to Reserve". But sometimes the words on screen are built from data. A small model once turned the live count "4 of 6 completed" into fixed text in a real app, so the counter stopped counting.
Now, when our editor cannot patch the text directly because it is computed, translated or ambiguous, the request goes to the main model. The rule costs a little on a few requests and protects the rest.
Let clients say what, never which model
The app should tell the server what kind of request this is, and the server should pick the model. Naming a model is spending money, so keep that choice on the server.
The GrowApps app sends a request kind from a fixed list, such as "text edit". Even accepting the backup model is a yes or no answer, not a model name. The server maps both to models it has priced and tested.
Test one lane at a time
Routing makes testing harder, because a session can touch several models. If a model test runs some turns on the candidate and some on a cheaper lane, the results mix two models and nobody can separate them afterwards.
So when we test a model on an account, that test overrides the cheap lanes too, on every turn.
Research backs routing
Routing between models is a studied idea, not just a cost hack. FrugalGPT sends a query to cheap models first and escalates only when needed. RouteLLM trains a router to choose between a strong and a weak model.
Libraries such as LiteLLM's router handle the plumbing: several models, retries and fallbacks behind one interface. The hard part stays yours: deciding which jobs a cheaper model may take.
How this works for GrowApps users
You never choose a model in GrowApps. You describe what you want, and each part of the work goes to the lane above. If the main model is too busy, the chat says so before switching to the backup and tells you how much more it costs.
You can see the builder at work on GrowApps.
Map your own AI jobs in ten minutes
List every place your product calls a model. Next to each, write "fully specified" if the input decides the output, or "must invent" if the model makes design choices. Send the first group to a small model and the second to a strong one, then spot-check ten outputs of each.
Sources and further reading
- FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance, Chen, Zaharia and Zou
- RouteLLM: Learning to Route LLMs with Preference Data, Ong et al.
- LiteLLM routing, LiteLLM documentation
- Gemini models overview, Google AI for Developers
- Building effective agents, Anthropic engineering
- Firebase AI Logic models, Firebase documentation