The best AI model shipped. Our token burn dropped.

Let me start with the model I am not writing about. OpenAI released GPT-6 Astra this week. Early accounts call it the best model in the world, and OpenAI's president said it could eventually be seen as AGI. It went out as a limited preview to a handful of organizations. I got access as this piece went live, so parts of it may change. Until then, the best model you cannot run is not the best model you have.

The one most of us can run is Fable 5.1. I have been running my company on AI models for a long time, and it is the first one in a while that made me want to move everything onto it the same day. It plans better. It reasons through a messy problem without losing the thread. It is also very good at graphics and page design. I did not expect that from a language model.

Then I did the arithmetic. We run a fleet of agents across several businesses, all of it on one shared plan, and they work around the clock. If every one of them ran every step on the top-tier model, my rough math said we would drain this week's allowance in about a day. Not because the hard work is expensive. Because the easy work is constant, and there is far more of it.

So the question was never whether to use the best model. It was where. And the answer became a rule we shipped across the whole fleet today, plus a version of that rule you can hand your own agent in about two minutes. It is at the bottom of this piece, and it is model-agnostic, so it works whatever you run.

Most of what an agent does is not thinking

Watch an AI agent work for an hour and most of what it does is errands. It opens files and reads them. It searches for where something is defined. It takes a pile of logs and boils them down to what went wrong. It writes a first pass at something you are going to rewrite anyway. It sweeps through forty items doing the same small check on each. None of that is thinking. It is fetching, reducing, and typing.

The thinking is a thin slice on top: deciding what to build before building it, reasoning through a call that has a cost attached, weighing two options a person will react to differently, designing how a page should feel. That slice is where a better model pays for itself, because the quality of the answer depends on the quality of the reasoning. Everywhere else, a cheaper model hands you a result that is good enough, because the next step checks it, at a fraction of the price.

Once you see the work split that way, the rule writes itself. Put the expensive model on the thin slice that is thinking. Put a cheaper one on the errands. The whole difficulty is making that split happen on its own, so it does not depend on anyone remembering to be careful in the moment they are busy.

The expensive model earns its price when the answer depends on how well it reasons. That is a small slice of the work.

Two tiers, and the agent picks its own

There are two tiers. The model you talk to, the one that plans and decides, stays on the strongest thing you have. Never downgrade the brain. Everything that model spawns, every helper it kicks off to run an errand, defaults to a cheaper tier: sub-agents that search and gather, workers, background tasks, loops, scheduled jobs. And the pure reading jobs, the ones that only reduce a mountain of text to a summary, drop one tier lower still, to the cheapest model you have, because a summary is judged by whether it is correct, not by what wrote it. Our gate spots those from the instruction alone: a job that says summarize, classify, or dedupe a pile of logs, transcripts, or tickets goes to the cheapest model with no phrase needed.

That default flips the economics. The cheap path becomes the path of least resistance instead of the thing you have to opt into. You stop paying top-tier prices for typing.

The five jobs that always keep the best model

There are five kinds of work where our agents keep the strongest model without having to justify it. They are the places where a cheaper model quietly costs you more than it saves:

• Reasoning, planning and strategy in the main session. The thinking itself. This is the entire reason you bought a better brain, so it never gets downgraded.
• Image and video creation: rendering, editing, composing. Fable is good enough at visual work that dropping a tier shows up in the output immediately.
• The definition of website design: information architecture, wireframes, layout, the design system, visual direction. Deciding how a page works and feels is design thinking, and it is the best model I have used at it. Turning that finished design into code is an errand, so that part drops to the cheap lane.
• Prose a person will read: a client email, an article like this one, a LinkedIn or X post, a newsletter, a report. Summaries the agent writes for its own use stay cheap; words a human reads do not.
• Judging quality: QA gates, scoring content, reviewing a design or a piece of copy. A weaker judge passes weaker work, so the reviewer stays top-tier even when the thing it is reviewing was made cheaply.

The second dial: how hard the model thinks

There is a second dial next to the model, and most people never touch it. The same model can run at different effort levels. Ask for low effort and it answers fast and cheap. Ask for high effort and it thinks longer, spends more tokens, and reasons harder before it commits. Same model, same price per token; it just spends more or fewer tokens reasoning before it answers. Low effort on a summary job. High effort on a bug whose root cause you cannot find. Which model you pick is one choice. How hard you make it think is another, and the two multiply.

The rule for effort is the same shape as the rule for models, and it follows the same map. Turn the effort up where the answer depends on wrestling with something ambiguous: finding the root cause of a bug, choosing an architecture, making a taste call, the five reserved jobs from a moment ago. Keep it low where the output gets checked by something other than the model anyway: a mechanical transform a test will catch, a summary you will read against its source, a draft you will rewrite. If a parser is going to catch the mistake anyway, paying for high effort is just wasted money.

I will be straight about where we are with this one: we have not shipped it as a rule yet. The model tiering above went live across the fleet today; effort is the next step, and right now every job runs its model's default. The direction is set, and it is the one you would guess: high effort in the session that reasons and on the reserved jobs, medium on the implementation a cheaper model does, low on the reductions and summaries at the bottom. The knobs are mechanical, a setting on the session and a flag on each scheduled job, so shipping it is a small change and not a new system. I would rather show you where this is going now than wait until it is finished.

• Introducing Claude Fable 5.1 (Anthropic) (The model this piece runs on. Anthropic's own release notes say it gets results similar to or better than its predecessor at low or medium effort, at much lower cost, and is capable of much higher performance at higher effort. That is the whole reason the effort dial is worth setting on purpose.)

Going up costs a sentence

Sometimes a spawned job does need the best model. When it does, you say so in one line when you launch it, and the system reads that line as the permission slip. Write the word judgment, a colon, then the reason. For example: judgment: this sub-agent is making the architecture call, not just fetching files. No line, no upgrade. And the reason gets written to a log, so the spend is a deliberate, visible choice instead of a quiet leak.

That one detail is what keeps the rule from rotting. Without it, "just this once on the big model" becomes every time, and you are back where you started. With it, going up is friction on purpose: small enough that a job that needs the big model will pay the sentence, large enough that a job that does not will take the cheap default and never bother.

A rule you have to remember is a rule you will break

I have written enough operating rules to know the ones that live in a document get followed for a week, and the ones that live in the plumbing get followed forever. So we did not post "please use cheaper models" on a wiki. We built it into machinery, and it went live across the fleet this morning. Three pieces do the work.

• A default. One account setting says every helper an agent spawns is mid-tier unless told otherwise. One line, and the cheap path is now the default path.
• A gate that rewrites. The moment an agent tries to launch a helper, a small watcher checks which model it asked for. If it asked for the top model with no judgment reason, and it is not one of the five reserved jobs, the watcher swaps it down before it starts and logs the decision, like a spending limit that catches a charge before it clears. You cannot forget the rule, because the rule runs whether you remember it or not.
• A pin on every scheduled job. Background and cron jobs do not read your interactive settings, so each one names its model out loud, and a check flags any new job that forgot to.

Pick one. If your agent runs on Claude Code, take the first. If you run anything else, OpenRouter, a custom loop, LangGraph, CrewAI, an IDE agent, take the second. Both are written for the agent to read, not for you: paste the block into its standing instructions and it follows the rule on its own.

• OpenRouter (One API key in front of many models. If your agent runs through it, the tiering is just which model you name for spawned calls.)

But won't the cheaper model make mistakes?

This is the fear that keeps people paying top-tier prices for everything, so I will answer it. Yes, a cheaper model is a little less sharp. It does not matter on the errands because the errands get checked. A summary gets read against the thing it summarized. A first draft gets rewritten. A search either points at the right file or it does not, and you find out in the next step. A mistake on an errand costs you a retry, not a bad decision.

The cheap model does the work that gets checked. The strong model does the checking. An errand can be a little off, because something downstream catches it. A judgment call cannot, so that stays on the big model.

If you only change one thing tonight

You do not need our whole setup to capture most of the savings. If you run an agent that spawns other agents, do this one thing first: set the default model for anything it spawns to a mid-tier model, and leave your main session on the best one. In Claude Code that is a single setting; most agent stacks have an equivalent. That alone moves the biggest and most constant chunk of spend, the sub-agents and the background jobs, off the expensive model, and it should show up in your usage fast.

Then add the escape hatch so you never feel boxed in: agree with yourself that the only way a spawned job goes back up to the top model is a one-line reason you write into it, and that you will keep those reasons somewhere you can see them later. That is the whole discipline. A cheap default, and a sentence to override it. Everything else we built, the hook that rewrites a job before it runs, the pins on the scheduled jobs, the log of what ran where and why, is just making that discipline automatic so nobody has to hold it in their head.

Scroll up, grab the download that matches your stack, and paste it into your agent's instructions tonight. Add the hook and the scheduled-job pins later, once the default has done most of the work; none of it is a prerequisite for starting.

The desks stay smart; everything under them got cheaper

The agents I actually talk to, the ones running each business, what we call desks internally, stay on the top model, because those are the ones doing the thinking. Everything underneath them got cheaper this morning, and I do not expect the work to get worse, because none of the work that got cheaper was thinking in the first place. The sub-agent that reads forty files has no reason to read them worse on a mid-tier model. The job that summarizes a day of logs is judged by whether the summary is correct, and that gets checked either way.

The wrong instinct feels responsible. That is why I am writing this down. Putting your best model on every task looks like taking the work seriously. It is not. You are spending your budget on errands and leaving less for the decisions that actually need the good model. It is the same mistake as paying your most expensive person to sort the mail, then having no budget left when a hard call lands on the desk.

Let the errands run cheap. Keep the big model for the calls that need it. Once that is in the plumbing you stop thinking about it. Fable 5.1 is the best model I have used, and because we only point it at the work that needs it, our token burn dropped the moment the default flipped. I can see it in the usage stats. On a flat plan like ours that means you stop hitting the ceiling; on API pricing it is the bill. Go set the default tonight.

• OpenAI announces GPT-6 Astra (CNBC) (The model this piece opens with: shipped this week to a limited preview, best-in-world by early accounts, and out of reach for almost everyone for now.)
• Claude Code (The agent tooling our fleet runs on, where the default-model setting and the spawn-time hook live.)
• Claude Code hooks (How a PreToolUse hook can rewrite a spawned job's model before it runs. This is the gate described above.)
• Claude Code: subagents (How a spawned agent decides which model it runs on. The seam the whole rule sits in.)
• Claude Code: settings (Where the default spawned-agent model and the effort setting live.)