🎛️ Comparing models by role

Imagine a auto repair shop. You don't use a pneumatic impact wrench to tighten an eyeglass screw, or a screwdriver to remove a truck wheel. Every job has the right tool — and using one that's too expensive is wasteful, while using one that's too weak means rework. With a subagent fleet is the same: the agent’s role determines the model. Whoever scans 200 files call for speed and low cost; whoever reason on an irreversible decision, you want the strongest engine. The map below is the heart of this module: a role × model matrix.

↑ The role × model matrix: each role lands in the column for the right engine. Highlighted pill = recommended default; dashed = second opinion from another provider.

The Claude family comes in three sizes, and each has a sweet spot. Haiku is the fast worker: scans, searches, summarizes, reads documentation. Sonnet is the everyday professional: builds and reviews code. Opus is the architect: reasons through difficult decisions, analyzes security, thinks deeply. It’s not “Opus is better, so I’ll use Opus for everything”—it’s “the role calls for this engine.”

The fleet doesn’t need to consist of just one family. The models GPT and the environment Codex (OpenAI CLI, covered in module 4.2) come in as a second look: a reviewer who thinks differently from the builder. Different families make different kinds of mistakes — so a finding that two providers confirm it’s much more reliable.

você > O Sonnet acabou de escrever este módulo de auth.
        Peça a um revisor em GPT/Codex pra refutar:
        onde isso quebra? Só os furos, sem reescrever.

# construtor (Sonnet) e revisor (outra família) erram
# de formas diferentes — a divergência é o valor.
# o que os DOIS apontam é o que merece atenção.

Beyond Anthropic and OpenAI, there’s an entire market — Google (Gemini), open models running locally, specialized providers. The mistake is memorizing names; the right approach is to think in terms of capability. For your matrix, every model falls into one of three classes, and you fit the role into the class—not the brand of the week.

Here's the central tension. A strong model thinks even more deeply, but it costs more and takes longer. A lightweight model is cheap and instant, but shallow. There’s no free lunch: you choose where to spend your reasoning depth. The operational question is simple — Is the cost of getting this role wrong high? If so, move up. If not, move down.

Switching models has a hidden cost: each subagent starts from scratch and needs to gather the context again. That’s why the switch pays off in large tasks, not in 30-second messages. And there are two trade-off axes: switching between level (Haiku↔Sonnet↔Opus) by depth, and switch provider (Claude↔GPT) for independence.

The destination is a heterogeneous fleet: several subagents pointing to different models, each in its own role. It’s not a homogeneous “all Opus” or “all Haiku” system—it’s a designed mix. And every mix lives under three forces pulling in opposite directions: cost, latency e quality. You don't maximize all three; you balances by role.

↑ The same matrix, now with the tradeoff explicit in each row. Notice: as the required quality rises, cost and latency rise too — and that's acceptable only for critical roles.

A heterogeneous fleet isn’t a single file — it’s a set of subagents, each with its own field model pointing to the engine behind your role. Below, four .md cropped side by side: notice how the role (in the description) e o model go together.

# ── file-scanner.md ─ papel: ESCANEAR (volumoso, raso) ──
name: file-scanner
description: Varre o repo e lista arquivos/símbolos
  relevantes. Use para mapear antes de qualquer leitura.
tools: Grep, Glob                # só localizar
model: haiku                      # barato + rápido

# ── builder.md ─ papel: CONSTRUIR (de ofício) ──────────
name: builder
description: Implementa a mudança descrita no plano.
tools: Read, Edit, Write, Bash
model: sonnet                     # equilíbrio

# ── arch-thinker.md ─ papel: RACIOCÍNIO (juízo) ────────
name: arch-thinker
description: Decide a arquitetura e os trade-offs de
  uma mudança grande. Use ANTES de construir.
tools: Read, Grep
model: opus                       # raciocínio profundo

# ── cross-reviewer.md ─ papel: REVISAR (2º olhar) ──────
name: cross-reviewer
description: Refuta o trabalho do builder buscando
  furos. Use após qualquer mudança sensível.
tools: Read, Grep
model: gpt-codex     # OUTRA família = independência

Three prompts for the orchestrator distribute models by role. The default is always to name the role and justify the engine — cheap where possible, powerful where needed, independent during review.

Para este job, monte uma frota por papel: use Haiku pra
escanear e buscar, Sonnet pra construir e revisar, e Opus
só pro raciocínio de arquitetura. Justifique cada escolha
em uma linha (custo/latência/qualidade).

O builder (Sonnet) terminou. Agora rode um revisor em
outro provedor (GPT/Codex) só pra refutar: liste os furos
que um modelo da MESMA família talvez não veja. Não
reescreva — só aponte.

Revise minha frota: que papéis hoje em Sonnet poderiam
cair pra Haiku sem risco (erro barato de checar)? E que
papéis merecem subir pra Opus porque o erro seria caro?
Devolva só a matriz papel → modelo ajustada.

This is how the heterogeneous fleet appears in the terminal: each subagent runs on model for your role, and the middle column shows which engine each one is using. Notice the relative cost on the right—the high-volume roles on Haiku cost almost nothing; only the reasoning on Opus adds up.

↑ Illustrative recreation of the terminal (not a real screenshot). Each subagent uses the engine suited to its role; the cost is concentrated only in the reasoning Opus.