Skip to main content

My Model Usage, July 2026: Receipts for the Routing Theory

· 12 min read
Gergely Sipos
Gergely Sipos
Frontend Architect

This is my token telemetry for July 2026 — one developer's month, pulled from the Aliz AI usage dashboard. Earlier this month I wrote You Don't Deserve Fable (Yet), which argued that routing discipline comes before reaching for the biggest model on the menu. This post is a month of receipts for that argument, including the parts where I plainly haven't applied my own advice. It's also a mixture of before and after: the routing discipline was still forming while the month ran, so this isn't a steady state. Some of the chart describes habits I'd already changed, and some of it describes habits I was in the middle of changing.

Donut chart of my July 2026 token consumption by model: claude-opus-4.6 at 48,341,414 tokens, claude-haiku-4.5 at 13,652,602, mai-code-1-flash-picker at 12,519,991, and gpt-5-mini at 8,864,236, followed by progressively smaller unlabelled slices for claude-sonnet-4.6, claude-sonnet-5, claude-opus-4.8, copilot-nes-lysithea-14, gpt-4o-mini-2024-07-18, and Others.

The Numbers​

Here is what actually happened. One thing to get out of the way first: only the top four slices are labelled in the dashboard. The rest are small enough that I can describe their rank but not their size, so I won't guess. Those rows below say not labelled, and that's where they stay.

ModelTokensShare (approx.)Role in my setup
claude-opus-4.648,341,414~halfOrchestrator, reasoning, final synthesis
claude-haiku-4.513,652,602~1 in 7Delegated subagent work — exploration, file reading, search, IO
mai-code-1-flash-picker12,519,991~1 in 8Delegated subagent work — same role (adopted mid-month)
gpt-5-mini8,864,236~1 in 10Delegated subagent work — same role
claude-sonnet-4.6not labelledsmallThe tier I under-use
claude-sonnet-5not labelledsmallSame tier, second generation
claude-opus-4.8not labelledsmallTried it, stayed on 4.6
copilot-nes-lysithea-14not labelledsmallInline suggestions, as far as I can tell
gpt-4o-mini-2024-07-18not labelledsmallIncidental
Othersnot labelledsmallLong tail

Only the top four slices carry labels in the dashboard. Shares are rounded against an approximate ~93M monthly total — treat them as directional, not exact.

The labelled slices account for the large majority of the month, which lands somewhere around 93M in total. Every percentage in this post is derived from that approximation and should be read as ± a few points.

With that caveat in place: Opus 4.6 is roughly half the month. Haiku is about one in seven tokens. The MAI flash-picker is a bit over one in eight. gpt-5-mini is just under one in ten. Those three small models are interchangeable in my setup — they all take the same kind of delegated work, and which one gets a given job is the orchestrator's call, not a role distinction. Combined, they're around 38–40% of everything I consumed.

Opus Is the Workhorse — and That's the Thing I Was Trying to Fix​

The biggest slice isn't really the headline. The direction of travel is.

My explicit goal for July was to reduce Opus consumption by substituting smaller models — with one non-negotiable constraint: no loss of response quality. I wasn't trying to make my sessions cheaper by making them worse. If a delegated task came back shallow or wrong, the substitution had failed and the work went back to Opus.

The chart is the receipt for that experiment. Nearly 40% of my tokens ran on cheap models, and I did not experience a drop in output quality over the month. The work that moved was work that didn't need frontier reasoning in the first place, which is exactly the claim the Token Optimization Guide makes — and this is me operationalising it.

The self-critical half: half the month still being Opus means the substitution is partial. It is not finished, and I'm not going to describe it as a success. A 38–40% small-model share is a decent position to be in, not a solved problem — and as the Sonnet section below shows, a chunk of that remaining Opus half is work that shouldn't be on Opus at all.

How the Cheap Tokens Get There: Orchestrator + Subagents​

The small-model share is not the result of me manually picking Haiku from the model dropdown. I would never have kept that up for a month. It's structural.

I start a session with Opus as the orchestrator. The orchestrator then decides which model each subagent gets, based on the complexity of the task it's handing off. Exploration, file reading, searching, and other IO-heavy work goes to Haiku, to the MAI flash-picker, or to gpt-5-mini — interchangeably, since they occupy the same rung. Opus keeps the reasoning and the final synthesis — the parts where the quality constraint actually bites.

The insight worth stating explicitly: the routing decision itself is a task I delegated to the model, not a discipline I have to exercise on every prompt. That's the only reason it holds up across a whole month of real work. Discipline I have to remember decays by Wednesday. Discipline encoded in an agent definition doesn't.

The mechanics live in Multi-Agent Orchestration — specifically the orchestrator + subagents pattern — and in subagent model routing. The agents that do the delegated work are defined per AI Coding Agents, and the rules themselves sit in Copilot Customization Files.

tip

If you want your own chart to look like this, don't try to remember to switch models. Encode the routing in your agent definitions and let the orchestrator apply it.

The New Entry: mai-code-1-flash-picker​

My #3 consumer at 12,519,991 tokens is a model I wasn't using at all at the start of the month.

mai-code-1-flash-picker sits in the model-picking and subagent layer of my setup. In practice it absorbed a meaningful chunk of the work that used to go to larger models — the same delegated, high-volume, low-reasoning work that Haiku and gpt-5-mini handle. That's a description of its role in my workflow and nothing more; I have no visibility into how it works internally, and I'm not going to speculate.

It also reinforces the before/after framing. Adoption started mid-month, so that number covers a partial month, not a full one. A full month at the same rate would push the small-model share higher than 38–40% without me changing anything else about how I work.

The Gap: Sonnet​

This is the clearest failure in the chart.

Sonnet-class models are noticeably under-utilised in my July. Both Sonnet slices sit in the unlabelled tail, which is not where a balanced routing setup would put them. There's a nuance that makes it look slightly worse than it is: Sonnet's already-small share is split across two generations, claude-sonnet-4.6 and claude-sonnet-5, so each slice looks even tinier than the combined reality. Combined, it's still small.

The diagnosis is that my routing is currently bimodal. Work either drops to a flash-class model or escalates straight to Opus. There's no middle. And there absolutely should be one: real production coding — the kind that needs more than exploration but less than architecture — is landing on Opus by default, because Opus is where the session already is.

That is precisely the escalation path I described in You Don't Deserve Fable (Yet), and I'm not walking it properly. I built the bottom rung and the top rung and skipped the one in the middle.

The August goal is to move that middle tier onto Sonnet. Stating it as a target, not an achievement.

Why I'm Still on Opus 4.6​

The tiny claude-opus-4.8 sliver is a deliberate choice rather than neglect.

I got used to 4.6. I know its failure modes, how it responds to my instruction files, and how it behaves when it's orchestrating rather than doing the work itself. That calibration is worth something. When I tried 4.7 and 4.8, neither brought improvements that mattered for my workflow, so switching would have cost me that calibration for no gain I could point at.

That's a statement about my setup, not a benchmark claim. Other people's workflows will have found things in those releases that mine didn't exercise.

The forward hook: Opus 5 landed today, and I started experimenting with it while writing this post. Whether it earns the orchestrator seat is next month's chart, not this one.

What the 40% Actually Saved​

Token share and cost share aren't the same thing. With premium multipliers on Opus-class models, that blue slice still dominates the bill, and no amount of small-model delegation changes the fact that frontier tokens are the expensive ones. Worth stating plainly.

It is not, however, a reason to shrug at the other 40% — and the distinction actually cuts the other way in my case. The work that ran on Haiku, the MAI flash-picker, and gpt-5-mini is not new work that appeared because cheap models were available. It's work that used to run on Opus. Every one of those tokens is a substitution, not an addition: exploration, file reading, search, and IO that would otherwise have been billed at frontier rates. Moving that volume down to flash-class pricing is a substantial saving, and it's the single biggest thing I changed all month.

Token mix is where the behaviour change is visible; the cost effect is real but compresses into a smaller-looking number. That compression is arithmetic, not evidence the effort didn't land. A cheap model consuming a lot of tokens shows up big on a token chart and small on an invoice — which is the entire point of the exercise. Judging the result by how far the cost pie moved would be reading the wrong chart.

Which is also why Sonnet matters. The remaining Opus half still contains middle-tier work that doesn't need frontier reasoning, and that's the most expensive mistake left in this chart: full frontier rates for work a cheaper tier would handle just as well. The first 40% was the easy substitution — high-volume, obviously mechanical, low risk to quality. The next slice is the harder one to route and the more valuable one to get right.

note

The cost side is worth measuring per session rather than per month. chronicle:cost-tips covers that, and the analyze your usage section has the broader approach.

A Note on Where This Data Comes From​

None of this is special access. The chart comes from the Aliz AI telemetry dashboard, and anyone at Aliz can see their own stats there.

One prerequisite: you need telemetry reporting enabled on your machine first. If you haven't set that up, the dashboard will just be empty for you.

As I understand it, this dashboard is org-level, which makes it a different thing from VS Code Chronicle — Chronicle reads your local session store, so it's per-developer and stays on your machine. The two complement each other rather than overlap.

One more observation from the tail: copilot-nes-lysithea-14 — what I believe is the inline Next Edit Suggestions model — is a sliver. If that identification is right, it's a neat confirmation that agentic chat, not inline completion, is where the tokens actually go.

What August Should Look Like​

July was a transition month. The routing discipline was still forming, MAI adoption started halfway through, and Opus 5 arrived on the last working day. This chart is a snapshot of a system in motion, not a steady state.

So, three predictions I can be held to:

  1. Sonnet visible as a labelled slice, absorbing the middle-tier work that currently escalates to Opus.
  2. MAI flash-picker higher, on a full month rather than a partial one.
  3. Opus share below half — though honestly, this one might not happen if Opus 5 turns out to be worth the orchestrator seat.

Publishing the predictions is the point. Next month's chart either backs them up or it doesn't, and either way it'll be more useful than another post about how I intend to route my tokens.

Further Reading​