# Model Selection Decision Tree — July 2026

```
as_of: 2026-07-12
tier: T3 (authored)
layer: Foundation
type: launch artifact — downloadable kit
note: every priced claim carries [VERIFY] — model prices change monthly; check the vendor pricing page on the day you decide
```

One page. Start at the top, follow the first branch that matches, stop at the first recommendation. The tree optimizes for "good enough at the lowest cost and complexity," not "best possible" — if you need best-possible, that is Branch 1D and you already know it.

Working definitions: **hard budget** = a monthly number someone will enforce. **Latency-critical** = a human is waiting on-screen for the answer. **Big context** = single requests over ~100K tokens.

---

```
START: What is the budget situation?
│
├─ 1A. Budget ≈ zero (hobby, internal tool, experimentation)
│   │
│   ├─ Have a machine with 16 GB+ RAM (or any decent GPU)?
│   │   └─ YES → GO LOCAL.
│   │       ├─ General chat/drafting .... Llama 3.1 8B or Qwen3 (small) at Q4
│   │       ├─ Coding .................. Qwen2.5-Coder 32B if you have ~24 GB;
│   │       │                            Qwen2.5-Coder 7B if you don't
│   │       ├─ Reasoning ............... DeepSeek-R1 distills (8–70B per your RAM)
│   │       └─ Embeddings .............. nomic-embed-text or bge-m3 (multilingual)
│   │
│   └─ NO capable hardware → free API tiers.
│       └─ Gemini Flash free tier or similar free allowances; accept rate
│          limits and that your data may be used per free-tier terms. [VERIFY]
│
├─ 1B. Small but real budget (~$5–50/month, indie or small team)
│   │
│   ├─ Latency-critical (chatbot, autocomplete, live UI)?
│   │   └─ YES → small fast API models.
│   │       ├─ Default ................ Gemini Flash class (~$0.10–0.40/MTok in) [VERIFY]
│   │       ├─ Anthropic stack ........ Claude Haiku 4.5 (~$1/$5 per MTok) [VERIFY]
│   │       └─ OpenAI stack .......... GPT-5 mini class [VERIFY]
│   │
│   └─ NO, throughput matters more than snappiness →
│       ├─ Bulk text processing ....... DeepSeek V3.2 API — consistently the
│       │                              cheapest near-frontier option (~$0.3–0.5/MTok in) [VERIFY]
│       └─ Anything sent to customers → step up one tier: Claude Sonnet 4.6
│                                       or GPT-5 class for the final pass only;
│                                       draft with the cheap model. [VERIFY]
│
├─ 1C. Production budget ($50–1,000/month) — pick by TASK TYPE:
│   │
│   ├─ Coding / agentic work (multi-step, tool use)
│   │   ├─ Default .................. Claude Sonnet 4.6 ($3/$15 per MTok) [VERIFY]
│   │   ├─ Alternative .............. GPT-5.x via API [VERIFY]
│   │   └─ Heavy daily use? A flat-rate seat (Claude Pro/Max $20–200/mo,
│   │      Copilot Pro $10/mo) usually beats per-token API. [VERIFY]
│   │
│   ├─ Long-context work (contracts, codebases, transcripts)
│   │   ├─ Need >200K in one request → Gemini 2.5 Pro class (1M-token window) [VERIFY]
│   │   └─ Under ~200K → Claude Sonnet 4.6 or GPT-5 class both fine;
│   │      consider RAG instead of raw context above ~50K — usually
│   │      cheaper and more accurate than stuffing the window.
│   │
│   ├─ High-volume classification / extraction / summarization
│   │   └─ Smallest model that passes YOUR eval set. Start Flash/Haiku/mini
│   │      class, only escalate on measured failure. Batch APIs give ~50%
│   │      discounts on all major providers for non-urgent jobs. [VERIFY]
│   │
│   ├─ Deep reasoning (math, analysis, planning)
│   │   └─ Reasoning-mode models: OpenAI o-series / GPT-5 thinking,
│   │      Claude with extended thinking, DeepSeek-R1 (cheapest of the
│   │      three). Expect 5–20x the tokens of a normal reply. [VERIFY]
│   │
│   └─ Embeddings at scale
│       └─ API: text-embedding-3-small class (~$0.02/MTok) [VERIFY],
│          or free local (nomic-embed-text / bge-m3) if you already
│          run a GPU box — at millions of chunks, local wins.
│
└─ 1D. Budget is not the constraint — quality or compliance is:
    │
    ├─ Data cannot leave your infrastructure (legal, medical, regulated)
    │   └─ LOCAL ONLY, buy the hardware the task needs:
    │       ├─ 70B-class (Llama 3.3/4, DeepSeek-R1 70B) ≈ 43 GB VRAM → used
    │       │   dual-GPU workstation, Mac Studio 128 GB, or Strix-Halo-class
    │       │   unified-memory box
    │       └─ Bigger open models (DeepSeek V3.x, Llama 4 large) need
    │           multi-GPU server class — at that point compare against a
    │           zero-retention enterprise API agreement before buying.
    │
    └─ Maximum capability, data restrictions manageable
        └─ Frontier tier: Claude Opus 4.x ($15/$75 per MTok) [VERIFY],
           GPT-5 high/pro tier [VERIFY], Gemini 2.5 Pro/Ultra class [VERIFY].
           Route only the hard 10% here; let Sonnet/Flash-class handle the rest.
```

---

## Local vs API — the actual tradeoff

Local wins when at least one is true: data cannot leave the building; volume is high and steady enough that electricity beats per-token pricing; you need offline; or predictable flat cost matters more than peak quality. Local costs you: setup and maintenance time, a quality ceiling roughly one tier below frontier APIs, and slow generation on big models (a local 70B runs ~10–20 tokens/second on prosumer hardware; APIs are typically 3–10x faster).

API wins when quality is revenue-relevant, volume is spiky, or nobody wants to babysit a GPU box. The hybrid most teams land on: local for embeddings, bulk drafts, and anything sensitive; API for the final-quality pass and agentic coding.

## Three rules that outlast any model list

1. **Build a 25-question eval set from your real workload before choosing.** Every vendor benchmark is somebody else's workload. The cheapest model that passes your set is the right model.
2. **Route, don't standardize.** One cheap default + one frontier escalation path beats one premium model for everything. Most production traffic is easy.
3. **Re-run the decision quarterly.** Prices and capabilities in this file have a half-life of months — that is why every number above says [VERIFY]. The tree's structure (budget → latency → context → task → local-vs-API) is the durable part; the model names at the leaves are not.