What Models We're Running In Q4 2026, and What We Quietly Stopped Using

Q4 2026 — what we run, what it costs, and how we decide as the technology moves.

The coding harness is the multiplier. The model is the judgment call. A fast harness on the wrong model burns money; a frontier model on a trivial task burns time. We run a senior-led, AI-accelerated studio, so every model choice has to answer one question: does this task need depth, or does it need speed?

Model lineups rotate, prices move, and the way a studio uses AI moves with them. This is how our setup adapted for Q4 2026 — a snapshot, not a recommendation, but the reasoning should transfer if you run AI-assisted work yourself. We have written before about choosing the harness; this is the other half of that decision.

We also name the two models we stopped using, and what each one lost its place to. That part is usually left out, and it is usually the difference between a model that fits your workflow and one that only looks like it does. If you run a subagent workflow of your own, we would genuinely like to compare notes.

WHAT WE OPTIMISE FOR

We pick models by task stakes, not by reputation.

No single model does both halves of our work well, so we don't ask one to. Strategic work — architecture decisions, brand vision, complex agent orchestration — is where we pay for depth. You pay more per token, but you use fewer tokens, because the model gets it right the first time.

High-volume execution — file edits, code search, routine subagent loops, context gathering — is where we pay for volume. You use more tokens, but each one is cheap enough that volume stops mattering.

The misroutes run both ways. Reach for the frontier model because a task feels important, and you can watch it spend four dollars negotiating a file rename. Drop to the cheapest model on a genuinely hard call, and you get a cheerful architecture you have to throw away. Neither is a model problem. Both are routing problems — which is why we watch our own operating cost rather than the headline price per token.

One name you will not find on the shortlist below: the closed frontier models. That is deliberate. Open-weight is where the real price competition lives, and cost-efficiency converts directly into leverage. The hours we spend reviewing models are what keep our operating cost at bay — and a lower operating cost means how much AI we deploy on a project is decided by the work, not by the bill.

WHY THE SPREAD IS WORTH MANAGING

Across the eight models we actively evaluate, published list prices at the time of writing span a wide band:

Input: $0.14 to $3.00 per 1M tokens — a 21x gap.
Output: $0.28 to $15.00 per 1M tokens — a 54x gap.

Input tokens are what you send: files, instructions, retrieved context. Output tokens are what the model generates: reasoning, tool calls, code, prose. Agentic work is output-heavy, because the agent is constantly deciding and emitting. That makes the output rate the number that actually lands in our operating cost.

So the lever, for us, was never "find a cheaper model." It was "stop sending expensive work to the expensive model." Those are different problems, and only one of them has a structural fix.

WHY SUBAGENTS ARE WHERE OUR MONEY GOES

A single long chat session has one model and one context. Every file it reads, every failed attempt, every dead end stays in that window and gets re-sent on the next turn. By hour three, that means paying frontier rates to re-read your own history — and by then the context is usually bloated enough that the model has started drifting.

It is also the reason two capable models came out of our rotation, which we get to below.

A subagent workflow changes the shape of our spend rather than the price of any single token:

Recon goes to the cheapest capable model. Reading files, searching a codebase, and summarising what matters does not require deep reasoning. It requires speed and a large context window.
Judgement stays on the expensive model. The architectural call, the final review, the decision that ships — that is where a frontier model earns its rate.
Every subagent gets a fresh context. Reconnaissance reads twenty files and returns three paragraphs. The parent never carries the twenty files.

That third point is the one most setups discover last. Subagents are not just parallelism. They are a way of buying context compaction — we pay a cheap model to absorb the noise, and the expensive model only ever sees the signal.

This is why we run a tiered setup rather than one good model. It is also why our spend dropped without any drop in quality: we did not make the frontier model better, we stopped asking it to do retrieval.

WHY WE STOPPED USING THEM

Kimi K2.5 and K2.7-code are the two models we retired most deliberately. The reason had nothing to do with benchmark scores. It was context.

For a long stretch we ran both heavily, and they did good work — strong on code, no complaints about output quality. The problem was how they spent their budget. Both consumed a large share of the context window on thinking tokens, and once that thinking filled the window, sessions degraded in a way that is hard to catch: context bloat, then drift, then a model quietly reasoning from a stale picture of the work.

Nothing errors when this happens. Throughput looks fine and the model keeps answering. It has simply stopped tracking the thing you actually asked for, and you find out in review.

So we moved off them for long agentic sessions — not because they were weak models, but because their context economy was wrong for the way we work. Context economy, not benchmark score, decides whether a model survives hour three of a real task.

Two things we check before adopting anything:

How much of the window does it spend on itself? A model that thinks generously is not free just because its rate is low.
What does the session look like at hour three? Benchmarks measure the first answer, not the four-hundredth.

If you hit the same wall, we would like to know how you got around it.

HOW WE SORT THEM

We keep two buckets, and we are deliberate about which one a task lands in.

Tier 1: Frontier — where we pay for judgement

High parameter counts, deep reasoning, high per-token pricing. These earn their rate when a mistake costs more than the tokens. Only one of the four below carries a route today — the other three are strong models whose depth is not the kind of judgement agency work pays for.

Kimi K3. Top-tier multimodal visual synthesis and narrative copywriting. Native 1M context window. Output runs $15.00/1M — the most expensive model we evaluate. We use it surgically, for roughly 5% of workload: initial brand guidelines, visual mood board breakdowns, and creative vision setting.
GLM 5.3 Max. Exceptional cross-lingual logic and deep agent reasoning, competitive with flagship frontier models on complex math and multi-agent coordination. Text-only input. Evaluated and benched: the reasoning is excellent, but not the kind our creative and strategic tasks need.
DeepSeek V4 Pro. Deep logical depth for novel algorithms and complex code refactoring, with excellent zero-shot instruction following. Lower per-token cost than Kimi K3 while matching flagship reasoning — evaluated and benched, because hard debugging is rare enough in our work that it never earns a route.
Qwen 3.8 XHigh. Extreme reasoning depth with an extended chain-of-thought budget. Strong on complex mathematical proofs and deeply nested logic. Evaluated and benched — our oracle and review roles run on Qwen 3.7 Plus at a fraction of the rate.

Tier 2: Workhorses — where we pay for volume

Low input and output costs, low latency, large context windows. These carry the day-to-day.

DeepSeek V4.1 Flash. Our best cost-to-performance ratio at $0.15 input / $0.60 output per 1M tokens. 1M context window with compressed KV cache. Top-tier terminal and repository-level coding. The driver for our interactive work.
GLM 5.3 Flash. Very fast inference at $0.15 input / $0.50 output per 1M tokens, with excellent multi-turn tool calling and agentic context handling. It ran our scout and context-builder roles during evaluation and was genuinely impressive — we simply settled elsewhere.
MiMo V2.5. The cheapest model in our active rotation at $0.14 input / $0.28 output per 1M tokens, with a 1M context window. This is what our scout and context-builder subagents run on, where speed and cost matter more than reasoning depth.
Qwen 3.7 Plus. A versatile middle-weight at $0.40 input / $1.60 output per 1M tokens. A good balance of structured coding, tool calling, and prose quality, with strong multilingual performance. Our default for analytical subagents that need moderate reasoning.

The shortlist, side by side

Four of these eight carry our day-to-day. The rest stay on the bench — good models we like, that the routing keeps not choosing.

WHAT WE ACTUALLY RUN

The buckets are how we reason. This is the configuration that survived contact with real deadlines.

Why it splits this way for us:

Cheap, fast eyes for recon. Scout and context-builder run on MiMo V2.5 — the lowest-cost model in our rotation. These roles read files, search codebases, and return compressed context. They do not need deep reasoning; they need speed and a clean handoff.
Mid-tier reasoning for analysis and review. Planner, advisor, researcher, and reviewer all run on Qwen 3.7 Plus with thinking scaled to the task. This model balances structured coding, tool calling, and prose quality at a cost that stays predictable across long sessions.
High thinking on the model that ships. The main driver runs DeepSeek V4.1 Flash at high thinking — the only entry in our quick-switch menu that carries a high thinking budget by default. This is the model that touches client code, runs terminal commands, and makes the calls that ship.
The reviewer gets the highest dial. Every change passes through a reviewer at high thinking before it merges. Senior engineers supervise every agent, but the reviewer is the last automated gate.

We benchmarked GLM 5.3 Flash as an alternative driver for scout and context-builder. It is exceptionally fast and cheap, and it did the job well. We route MiMo V2.5 there anyway, because the cost difference is marginal and the routing has been stable. That is the least romantic sentence in this post, and it is the most honest one: our routing is often decided by inertia and a clean diff, not by a benchmark table.

THINKING LEVEL IS THE SECOND DIAL

Model choice is only half the decision. Thinking level is the other half.

The same model behaves differently at low versus high thinking. Low thinking burns fewer output tokens and responds faster. High thinking spends more on internal reasoning but produces more reliable results on complex tasks. Since output tokens are where our money goes, this dial moves our operating cost as much as the model choice does.

Where we set it:

High thinking — DeepSeek V4.1 Flash (main driver) and Qwen 3.7 Plus (reviewer). The two roles where a wrong answer costs us most: the model that writes client code, and the model that reviews it before merge.
Medium thinking — Qwen 3.7 Plus (planner, advisor, researcher, oracle). Enough depth for analysis and orchestration without paying the high-thinking overhead on every call.
Low thinking — MiMo V2.5 (scout) and Qwen 3.7 Plus (worker, delegate). Fast and cheap, which is sufficient for execution tasks where a senior engineer is already supervising the output.

Our default across the setup is low. We raise it deliberately, per role, when the stakes demand it. Turning every dial to high is not rigour — it is an unmetered cost, and it makes the expensive roles indistinguishable from the cheap ones.

CREATIVE & BRAND WORK

Volume execution and creative direction need different models, and ours diverge further here than anywhere else.

When a design project starts, we switch the main driver to Kimi K3 — the most expensive model in our rotation, and the strongest at multimodal visual synthesis and narrative copywriting. Its first job is not visual at all: it is the strategic work the whole workflow stands on. Copywriting, vision exploration, the problem statement, brand messaging — the strategic artifacts that tell every downstream agent what to build toward, all drafted before a single colour is chosen. We have written about why these artifacts are the prerequisite for AI-accelerated design. Only then does it set the visual direction and break down complex mood boards.

Once the design language is locked, we switch back to DeepSeek V4.1 Flash for the actual frontend build. Kimi K3 sets the vision; DeepSeek V4.1 Flash ships it. The output-cost difference is 25x, so we spend the premium where it compounds — the first 5% of creative work — and save on the remaining 95% of volume execution.

That is the same logic as the tiers, applied to a single project: we pay for depth at the top, pay for speed in the middle, and we do not run a frontier model on a task a Flash model handles well.

WHAT THIS BUYS OUR CLIENTS

Three outcomes that matter on every engagement.

Predictable operating cost. Keeping expensive models off high-volume work is the single biggest control we have: a day of interactive coding on DeepSeek V4.1 Flash at high thinking costs a fraction of the same day on Kimi K3, and subagent loops on MiMo V2.5 and Qwen 3.7 Plus stay in the sub-dollar range per session, because the reconnaissance never touches an expensive model at all.
Senior oversight stays intact. Every model choice is a human decision. The planner runs at medium thinking before anything starts; the reviewer runs at high thinking before anything merges. AI accelerates boilerplate and routine work; senior engineers own every architectural and quality decision.
Shipped product, not stalled experiments. Fast models on fast tasks keep the interactive loop responsive. Frontier models on frontier tasks give the hard decisions the depth they need. The result is a studio that ships — supervised by senior engineers, routed by the right model for each job.

OVER TO YOU

We have shown you ours. We would like to see yours.

Specifically, we are curious about:

Which models you route to which roles, and whether that mapping has survived contact with real deadlines.
Whether you have hit the same context tax we did, and what you did about it.
Where you have decided not to use a subagent, because the orchestration overhead exceeded the saving.
Any model you adopted enthusiastically and then quietly retired.

The last two interest us most. Most writing on agent workflows catalogues what works; far less records what was abandoned — and the abandoned half is usually the more useful one to read.

READY TO SHIP YOUR VISION?

AI should accelerate execution, not replace the judgment behind it. If you want a senior-led team that routes the right model to the right task under tight human control, let's talk.

Discuss Your Project