Two numbers from the last two months.
Open-source models went from 28% to 62% of tokens served at Vercel. The chart came from Vercel's Guillermo Rauch, and investor Gavin Baker set out the figures. And AT&T, which routes roughly 45 billion tokens a day through its internal platform, moved about 40% of employee AI queries to open models and intends to reach 60–70%. Coding and other advanced tasks got cheaper by as much as 56%, against a quality drop of about 2%.
Neither of those is a story about a model. They are stories about a policy: a written rule that decides which model gets which task, applied consistently.
Most founders do not have one. They have a default model chosen months ago, an occasional guilty glance at the billing page, and a vague sense that some of this work does not need the expensive thing.
Here is the single most useful thing in this whole resource, and you can act on it without signing up for anything:
Write the rule for the task, not the model. Every routing policy that survives contact with reality keys on properties of the work (does it use tools, how many tokens, is the output customer-facing, does it touch money or law) and never on a model's name. Model names and prices change on someone else's schedule. "Anything customer-facing where one factual error is unacceptable" was true last year and will be true next year.
That single inversion is why most people's routing setups rot. They hardcode claude-opus-4-7 and kimi-k2-6 into a config, ship it, and by the time anyone looks again the names are wrong, the prices have moved, and nobody dares touch it. A tier-based file survives all of that: you change three lines at the top and every rule underneath still holds.
A sample, so you can see the shape. This is the downshift rule, the one that pays for itself fastest, because classification and routing calls are usually the highest-volume, lowest-stakes traffic in the whole stack:
```markdown
Route to CHEAP when ANY of these is true
- The task is classification, routing, labeling or re-ranking
- The output is structured (JSON / function call) under 1K tokens
- The result feeds another model rather than a human
- Cost per call must stay below $0.001
```
Four lines. No model names. Point CHEAP at whatever is cheapest and adequate this quarter, and the rule never needs rewriting.
The full file is below: three tiers, the escalation rules, the 90-day re-evaluation loop, the eval that tells you where your line is, and seven copy-paste prompts for the work founders actually hand to models.
The Routing Rules File
Drop this at the root of your project as routing-rules.md, or paste it into your CLAUDE.md / AGENTS.md. Every agent, script and teammate reads it before picking a model.
```markdown
Last reviewed: <DATE> Next review: <DATE + 90 days>
Tier definitions — the only lines you edit when the market moves
CHEAP = <model> # cheapest thing that passes your eval DEFAULT = <model> # your workhorse ESCALATE = <model> # your most capable, most expensive
DEFAULT handles anything that is not named below.
Route to ESCALATE when ANY of these is true
- The output is customer-facing AND a single factual error is unacceptable
- The output touches auth, payments, PII, legal, medical or compliance language
- The task is long-horizon: it must stay coherent across many dependent steps
- The task is pure reasoning with no tools and no retrieval to lean on
- A DEFAULT attempt already failed twice on this exact task
Route to CHEAP when ANY of these is true
- The task is classification, routing, labeling or re-ranking
- The output is structured (JSON / function call) under 1K tokens
- The result feeds another model rather than a human
- Cost per call must stay below $0.001
Never route on
- The model's name, or which lab made it
- What was fastest six months ago
- Which tab happens to be open
Re-evaluate on a timer AND on an event
Timer: every 90 days. Event: immediately, whenever a model in any tier is superseded or repriced.
Sample 20 real tasks from each category. Replay each across all three tiers. Grade blind. Update the tier definitions if the cost or quality gap has shifted. Record the review date above. If Last reviewed is more than 120 days old, this file is fiction. ```
Why the escalate list leads with consequences
The first two rules in the ESCALATE block name something that is expensive to get wrong, rather than something that is hard, and that is the pair to copy first. "Hard" is a property of the model and moves constantly. "A wrong number here costs us a customer" is a property of your business and does not. A rule written that way survives a model generation; a rule written the other way does not.
The two middle rules are hardness properties, deliberately. Long-horizon coherence and unaided reasoning are the places where tier gaps are still real, and pretending otherwise to keep the list tidy would cost you correctness.
The last escalate rule (a DEFAULT attempt already failed twice) is the one people leave out, and it is the one that saves the most money. It converts escalation from a guess made up front into a fallback triggered by evidence. Most tasks never trigger it.
The counter-rule nobody writes down
Cheaper is not automatically cheaper. A cheap model that needs three attempts, a longer prompt and a human to check it costs more than one expensive call that lands first time. Cost per successful task is the metric; cost per token is the sticker price.
So the re-evaluation loop grades on outcomes, not on spend. If your CHEAP tier is quietly running everything twice, it is not your cheap tier.
That is also why the $0.001 in the routing rule and this metric are doing different jobs. Cost per call is a precondition: a cheap enough sticker price to be worth trying at all. Cost per successful task is the verdict, and only the eval can return it.
The eval that finds your own line
The AT&T number people quote is the 56%. The number to actually steal is the 2%, because it is the one that makes the trade legible at all. A cost saving with no measured quality cost next to it is not a result, it is a hope. AT&T can state the cost because somebody measured the output both ways.
To be exact about what that 2% is: it is a decline observed once routing was running. Which is the honest order anyway. You rarely know your tolerance until you have seen what the cheap tier actually does to your work. The point is to end up holding the number, not to have guessed it first.
You can run a much smaller version of this in an afternoon.
Step 1: Pick your three highest-volume tasks. Not your hardest. Your most frequent. Volume is where routing pays.
Step 2: Write down what a bad answer looks like for each one, before you run anything. Two or three sentences. This is the part everyone skips, and it is the entire experiment. Without it you are not evaluating, you are vibing.
Step 3: Pull 20 real inputs per task from your logs. Real ones. Not ones you invented, which are always cleaner than production.
Step 4: Run all 20 against each tier. Same prompt, same inputs.
Step 5: Grade blind. Strip the model names before you look. This matters more than it sounds: knowing which model produced an answer changes how you read it, reliably and in the direction of the expensive one.
Step 6: Count. You now have a defect rate per tier per task. Your routing rule for that task is: use the cheapest tier whose defect rate you can live with.
If you cannot tell the tiers apart, you have been paying premium prices for commodity output. That is a good outcome: take the money.
If the cheap tier fails badly and specifically, note how it fails. A tier that is wrong on the same input every time is fixable with a rule. A tier that is wrong on random inputs is not, and belongs nowhere near production.
Seven prompts for the work founders actually hand to models
Copy-paste, bracketed slots to fill. These are the recurring jobs, the ones worth having a saved prompt for rather than rewriting badly at 11pm.
1. Investor update memo
``` Draft my monthly investor update for [month].
Inputs: [Stripe export] · [product metrics] · [last month's update, same structure] · three customer wins listed below.
Structure:
- One-sentence headline takeaway
- The number that defined the month
- Highs (3 bullets, one sentence each)
- Lows (2 bullets, one sentence each, no spin)
- What I need from this group (3 specific asks)
Tone: founder-direct. Never "excited to share". Numbers over adjectives. Target length: 800 words. ```
2. Investor update deck
``` Build a 12-slide investor update deck for [company]. Audience: pre-seed and seed investors already on our cap table. Period: last 30 days.
Slides: headline number · revenue and growth · product launches · customer wins (named if logoable) · hiring · burn and runway · one thing that didn't work · what I need help with · asks (intros, hires, leads).
Style: clean, founder-direct, no marketing language. One chart per slide where useful. Pull all factual content from the attached [doc or transcript] — invent nothing. ```
3. Landing page with email capture
``` Build a landing page for [product]. Audience: [ICP in one sentence]. Goal: capture emails for early access.
- Hero: one-sentence value prop + email capture
- Three feature blocks, built from the attached one-pager
- Social proof: three logos, one quote
- FAQ: six questions, each answered in plain prose, answer-first
- Footer with privacy and terms placeholders
Visual style: clean, generous whitespace, [brand palette]. ```
4. Market intelligence report
``` Deep research report on the [category] market.
- Market size today and 3-year trajectory, with sources cited inline
- Top 10 players: pricing, target customer, key differentiator, recent funding
- The 3 customer segments inside this category and each one's pain
- Top 5 trends shaping the next 12 months
- Two non-obvious openings for [our product]
Output: 3,000-word memo, inline citations. Flag any claim whose underlying source is more than 18 months old. ```
5. 24-month financial model
``` Build a 24-month financial model for a B2B SaaS startup.
Starting state: MRR [$15,000] · growth [15% MoM decaying to 8% by month 18] · gross margin [80%] · CAC [$300] · payback [9 months] · headcount [4 at $120K loaded].
Four tabs: P&L (monthly) · cash flow (monthly) · runway (assume a [$2M] round in month 6) · sensitivity (growth 5%–25% MoM, show runway impact). Three charts: MRR trajectory, cash balance, headcount. ```
6. Competitor sweep, parallelised
``` Analyze the top [100] tools in [category]. For each, extract: pricing model and current price points · target customer (size, role, industry) · three most prominent homepage features · most recent changelog update · funding history and last round.
Run these in parallel. Output one comparison table, one row per tool, plus a 500-word summary: who competes with us most directly, where the white space is, and two candidates to partner with rather than fight. ```
7. Feature launch, four agents
``` Launch [feature] in seven days. Coordinate four agents:
- Researcher: synthesize the attached customer interviews and competitive
positioning into a one-page launch brief.
- Writer: from that brief, draft the launch post, the email, and three LinkedIn
variants in our voice (see [/style/voice.md]).
- Designer: hero image, three social cards, one feature graphic, using our brand kit.
- Publisher: schedule the email for [Tuesday 9am ET], queue the posts across three
days, prepare the post for publication.
Pause for my approval after each agent finishes. Do not publish without explicit confirmation. ```
Prices, and why there are so few of them here
One dated table, for the only figures independently confirmed on 25 August 2026:
- GPT-5.6 Sol — $4 · $20 · Cut from $5 / $30 on 21 Aug 2026; promotional, at least through 21 Nov 2026
- GPT-5.6 Terra — $2 · $12 · Since 30 July 2026
- GPT-5.6 Luna — $0.20 · $1.20 · Since 30 July 2026, an 80% cut
That is the whole table, deliberately. Every other price we could have listed came from a source we had not re-verified this week, and a stale price in a routing file is worse than no price: it produces confident decisions from wrong inputs.
Note the last column on the first row. The Sol discount is promotional, held at this level at least through 21 November 2026, and a routing rule written as though it were permanent may quietly stop being true after that. This is exactly why the file above keeps model names and market prices out of the rules themselves. The names sit in three tier definitions you re-check, and a market price appears nowhere in it at all.
The one dollar figure that does appear inside a rule, cost per call below $0.001 in the CHEAP block, is deliberate, and it is a different kind of number. It is a budget you set, not a price a vendor set. Your own thresholds belong in the rules. Someone else's price list does not.
Fill in your own numbers. Date them. Re-run the eval in 90 days, or the day a tier gets repriced, whichever comes first. The row above is a live example of the second case.
