# Which Model, Then? **The Binding Has an Expiry Date**

Published: 2026-07-07T21:20:00.000-04:00
Tags: agents, llm, ai-development, adlc
Canonical: https://www.voodootikigod.com/adlc-10-which-model-then

> The series routes by tier and never names a model. This post does: phase-to-tier doctrine, a July 2026 binding, and the machinery that keeps it honest.

---

Nine posts of this series route work by *tier* (cheap, mid, frontier) and never once tell you which model to put in each slot. That was deliberate, and readers noticed anyway. The most common question I get after [Three Dials](/adlc-5-three-dials-parallel-agents) is some form of: *fine, route by escape cost, but which models do I actually configure?*

The refusal had two honest reasons. First, the doctrine is about structure, not SKUs: [you never need a model smarter than the gate it must pass](/adlc-7-built-with-the-lifecycle), and that sentence stays true through every product launch. Second, any concrete answer rots. The model market turns over its leaderboard roughly every eight weeks; a post that says "use X for builds" is misinformation with a byline by Christmas.

But a permanent refusal is a cop-out, because every team faces the binding problem on day one: before their ledger has a single sample, someone has to type a model ID into a config file. So this post does both jobs the honest way: the **durable part** (which *tier* belongs on which phase, and why; this doesn't rot), the **perishable part** (a concrete binding as of July 2026, across the major providers and the local options, presented as a worked example with its expiry date printed on the label), and the **machinery** that makes the perishable part obsolete for you, specifically, as fast as possible.

## The durable part: phase → tier

[Principle 7](/adlc-5-three-dials-parallel-agents) in one line: **model tier is a function of the cost of *detecting* an error, not of task prestige.** Where rails catch errors instantly and deterministically, the cheapest model that clears the gates is correct. Where an error escapes every gate (a subtly wrong requirement, a subtly wrong contract) you spend everything you have, because detection is the expensive half. The routing quantity is *probability an error survives all gates × blast radius*, and that quantity is computable per phase:

| Phase | Tier | Why |
| --- | --- | --- |
| **P0 Triage** | cheap | Classification with low escape cost: a mis-triaged ticket is caught by the lifecycle it's routed into. |
| **P1 Interrogate** | **frontier** | The spec is the least-verified artifact in the system. A wrong requirement sails through every downstream gate wearing a green checkmark. Do not economize here. |
| **P2 Decompose** | **frontier** for contracts; **cheap** as the gate probe | Interface contracts are frontier work for the same reason specs are. But the cold-start gate *deliberately* hands each ticket to a cheap model and asks "what's missing?" If the cheap model can enumerate the gaps, the ticket is underspecified for the mid model that will build it. This is the one place a weak model is the *point*. |
| **P3 Rail** | mid | Tests and stubs authored from spec alone, in fresh context, with hollow-test checking them deterministically. The rails carry the risk, so the author doesn't have to. |
| **P4 Build** | router-decided | The [cost dial](/adlc-5-three-dials-parallel-agents): float and dense rails → start cheap and ladder up on gate failure (escalation is regeneration, never rescue, per [F8](/adlc-1-models-arent-human#f8)); critical path → skip the ladder, go straight to the best first-pass tier in your ledger. |
| **P5 Prosecute** | mid, **stacked**, plus a second *family* at high blast radius | N fresh-context mid passes with a loop-until-dry exit beat one frontier pass, and calibration can prove it for your repo. More on the family requirement below. |
| **P6 Integrate** | none | Behavior-diff is deterministic. The human is the frontier tier at this gate. |
| **P7 Distill** | mid, renting one frontier pass to mint structure | Lesson mining runs on mid. Occasionally rent the big model to crystallize judgment into a skill, a lint, a template. Then spend mid inside that structure indefinitely. Banking, not presence. |

Notice the spend shape this produces: heavy at interrogation and prosecution, light in the middle. That is the [barbell](/adlc-6-lifecycle-gets-cheaper) falling out of the routing math rather than being imposed on it.

One framing rule before naming names: **"frontier" means the best model you are allowed to run, not the most expensive model that exists.** The lifecycle's design center is an Opus-class ceiling. It must hit its accuracy targets with ordinary commercial tiers, because that's [the common enterprise reality](/adlc-7-built-with-the-lifecycle): approved-model lists, quota ceilings, procurement lag. The ultra tiers (Fable-class, Pro-class reasoning SKUs at 5-10× the price) are headroom for your hardest interrogation problems, never a requirement. A lifecycle that *requires* the most expensive model to function is a lifecycle without gates.

## The perishable part: the July 2026 binding

Everything in this section decays. Prices are USD per million tokens, input/output, standard rates. Benchmark numbers are directional. SWE-bench *Verified* and SWE-bench *Pro* are different benchmarks whose scores must never share a sentence without a warning label, so here's the label.

| Tier | Anthropic | OpenAI | Google | xAI / open-weight |
| --- | --- | --- | --- | --- |
| cheap | Haiku 4.5 ($1/$5) | GPT-5.4 nano ($0.20/$1.25) | Gemini 3.1 Flash-Lite ($0.25/$1.50) | Grok 4.1 Fast ($0.20/$0.50) · DeepSeek V4 Flash ($0.14/$0.28) |
| mid | Sonnet 5 ($3/$15) | GPT-5.4 ($2.50/$15) | Gemini 3.5 Flash ($1.50/$9) | Kimi K2.6 ($0.55/$2.65) · GLM-5.2 ($1.40/$4.40) |
| frontier | Opus 4.8 ($5/$25) | GPT-5.5 ($5/$30) | Gemini 3.1 Pro ($4/$18) | Grok 4.3 ($1.25/$2.50) · DeepSeek V4 Pro |
| above ceiling | Fable 5 ($10/$50) | GPT-5.5 Pro ($30/$180) | n/a | n/a |

The specific rows will be stale before you finish rolling them out. What's worth internalizing is the *structural* facts underneath, because those change slower:

**The tier↔price correlation has come loose in both directions.** Grok 4.3 posts frontier-adjacent coding numbers at mid-tier-cheap prices; GPT-5.5 Pro costs 36× Grok's input rate without being 36× anything. "Expensive therefore capable" was always a weak heuristic; in July 2026 it's just false. This is why the router routes by *measured first-pass rate per tier*, not by price band.

**Open-weight crossed the mid-tier line.** DeepSeek V4 sits at the top of the open SWE-bench Verified table; GLM-5.2 and Kimi K2.6 beat a closed flagship on SWE-bench Pro. The practical consequence isn't ideological. It's that the cheap and mid tiers now contain *distinct model families* at prices that make stacked prosecution passes nearly free.

**Local is a real tier now.** A single 24-32GB consumer GPU runs a competent cheap tier (Qwen3-Coder-30B, Devstral Small 2). A Mac Studio with 64-128GB of unified memory runs Qwen3-Coder-Next at ~70% SWE-bench Verified: a legitimate *mid* tier for rail-dense builds, at marginal cost ≈ 0. Two routing consequences follow. First, a free ladder start changes the ladder math: for float-rich tickets, failed cheap attempts cost only wall-clock that the float absorbs, so the rail-density floor for "try cheap first" can loosen. Second, the cold-start probe is the perfect local job: free, private, and the *weaker* the probe, the more honest the gate. And one hard limit: the single-machine ceiling is a mid tier. Do not put a local model on P1/P2 frontier duties; those phases exist precisely because their errors escape gates, and escaped-error cost is where the capability gap bites hardest.

## Family is a routing dimension, not just tier

The tier abstraction hides one thing that matters at exactly one phase. Within a model family, blind spots correlate: the same training lineage that makes a builder miss a class of bug makes its sibling reviewer miss the same class. [Prosecuting the Gates](/adlc-9-prosecuting-the-gates) showed the single-context version of this: never judge work your own context produced. The family version is weaker but real: a same-family prosecution stack, however many passes, keeps some of the builder's blind spots.

The fix costs almost nothing given the price table above: at high blast radius (trust boundaries, deny paths, auth, secrets, data loss, schema migrations, CI/CD), add one prosecution pass from a *different* family and treat any single family's clean approve as advisory. When I ran a cross-family pass over this toolkit's own gate code, the second family surfaced roughly seventeen deny-path bypasses that same-family prosecution had approved. Not seventeen findings. Seventeen *bypasses of the security gates*, found only when the reviewer's priors differed from the builder's. The open-weight mid tier makes this insurance nearly free: an Anthropic-primary shop adds GLM-5.2 or Kimi K2.6 as the second family for cents per review.

## The machinery: how a binding stays honest

[Principle 10](/adlc-6-lifecycle-gets-cheaper) eats its own routing table here: **a published model recommendation is a cache, and caches need invalidation.** Every artifact the next agent reads goes stale and then actively injects misinformation with the voice of authority. A model-recommendation table is the fastest-rotting artifact in the whole lifecycle. So the toolkit treats its own binding the way it treats every other cache:

1. **Date-stamp it.** The [toolkit's binding document](https://www.agenticlifecycle.ai/docs/reference/models-by-phase?ref=voodootikigod.com) opens with its snapshot date and a warning, not with the table.
2. **Let the ledger override it.** Every gate already logs model × ticket-category × first-pass outcome into the evidence manifest. After roughly three samples per tier, *your* ledger is a better routing table than *anyone's* published recommendation, including this one. The published binding is a cold-start prior, nothing more, and the router prefers the ledger the moment it exists.
3. **Re-verify on churn, mechanically.** A new model ships, or a provider silently revs a checkpoint: the model ratchet schedules re-prosecution of the hot paths, and review-calibration re-measures planted-bug recall *before* the new model is trusted in the reviewer seat. "The new model is better" is a claim; recall against planted bugs is a measurement.
4. **Measure the stack, never the model.** A 3-pass mid stack at 0.85 recall *is* the more capable reviewer than a 1-pass frontier model at 0.6, whatever the tier labels say. Tune N until the stack hits the target; stop believing labels, including the labels in this post.

That machinery is why the series could afford to speak in tiers for nine posts: the abstraction wasn't evasion, it was the only layer of the answer that *doesn't* expire. Phase→tier is doctrine. Tier→model is a dated cache with an owner and an invalidation trigger. Conflating the two is how every "best model for coding, {current_year}" listicle becomes a liability: they publish the perishable part with the confidence of the durable part and no machinery in between.

So: which model, then? For the next few weeks, the table above. For every week after that, your ledger already knows, and it never had a byline to protect.

---

*The full, maintained binding (including per-provider tables, local hardware classes, and the P5 cross-family quorum suggestions) lives in the toolkit at [agenticlifecycle.ai/docs/reference/models-by-phase](https://www.agenticlifecycle.ai/docs/reference/models-by-phase?ref=voodootikigod.com).*

*Start of series: [Stop Running the SDLC on Models That Aren't Human →](/adlc-1-models-arent-human)*