AI models

The families, the tiers, and how to pick without chasing leaderboards.

Underneath every tool in this guide is a model: a large language model (LLM) trained on a huge share of the world's text and code. The model is the brain; the tool you type into is the body around it. Get a few ideas about models straight and you can skip the endless online discourse entirely.

Labs ship families, not models

Each frontier lab releases a whole family with tiers, never one single model. There's always a fast, cheap tier for everyday work and a heavyweight tier for genuinely hard problems:

The practical rule: run the everyday tier by default, and escalate to the heavyweight only when something is genuinely hard, like a stubborn bug, a big refactor, or an architecture decision. Heavyweight models cost several times more per request, so for routine edits they're overkill. (Inside a coding agent you often don't pick at all: Codex quietly runs a coding-tuned GPT-5-Codex model, and the agents choose sensible defaults for you.)

The most powerful model right now: Fable 5

A word on the current king. In mid-2026 Anthropic released Claude Fable 5, the first of a new tier that sits above even Opus, and it is the strongest coding model anyone has shipped. It tops the hardest agentic-coding benchmarks by a wide margin, and the real-world stories match: Stripe reported Fable 5 performing a codebase-wide migration across a 50-million-line codebase in a single day, work that would have taken a team of engineers over two months by hand.

The catch is appetite. Fable 5 costs roughly twice what Opus does per token and about ten times what Haiku does on output, and because it thinks so hard, it burns through a lot of tokens doing it. It's a Ferrari, and you don't take a Ferrari to the grocery store. Reach for Fable on the genuinely hard, high-stakes work (a nasty migration, a subtle architectural bug, the plan for a big feature) and let cheaper models handle everything else.

Spending the big model wisely

The clever pattern people have landed on is to stop imagining one model doing everything and start running a team. Put Fable in the orchestrator (or planner) seat, where its judgment is worth the premium: it reads the problem, writes the plan, and delegates the actual typing to cheaper workers like Sonnet or Haiku. Fable thinks, the cheap models execute, Fable checks the result against its plan.

The savings are real. Published breakdowns of this setup show mixed fleets running roughly 60% cheaper than all-Fable, and a Fable-plus-Haiku split landing around 70% cheaper, for output that's nearly as good, because the hard thinking still happened up top. It's the same plan-with-the-heavyweight, build-with-the-fast-tier rhythm you'll meet in the Build section, just formalized into a standing crew. (People running the self-hosted agents from the Agentic workflows section often wire Fable in as exactly this planner brain.)

• –Orchestrate, don't micromanage. In Claude Code, plan mode plus subagents already does a soft version of this: Fable plans, its helpers run on lighter models. Community plugins push it further with explicit model-tier routing.
• –Cache what repeats. Prompt caching lets you reuse a big chunk of unchanging context (your project rules, a large file) instead of paying to resend it every single turn.
• –Batch the non-urgent. Work that doesn't need an instant answer can be sent in batches, which providers price well below real-time requests.
• –Set a hard spend cap. The one non-negotiable. A powerful model in a long loop can run up a bill fast, so cap it in your provider's billing settings before you point it at anything that runs unattended.

One honest caveat: orchestration has its own overhead, since routing a job through a planner adds a few hundred tokens each hop. For a simple one-shot task, just asking a cheap model directly is cheaper than convening a committee. The crew earns its keep on big, parallel, or long-running work, not on quick edits.

The same model can think harder

A newer wrinkle worth knowing: on top of the tiers, many models now take a reasoning effort setting. GPT-5.5, for example, runs from low up through high and xhigh, where higher settings make the same model think longer before answering. More effort means better results on hard problems, at the cost of more time and more tokens. Dialing effort up for a thorny bug and back down for routine work is its own small skill.

Beyond the big labs

The closed labs above aren't the whole map. A wave of open-weight models, ones you can download, run locally, or rent cheaply, has caught up fast on coding: DeepSeek and Qwen (permissively licensed and inexpensive), Kimi (tuned specifically for long agentic coding loops), and GLM. You don't need these on day one, but it's worth knowing the frontier isn't only rented from three companies. If you ever want to keep code entirely on your own machine, this is the branch you'll explore.

Taste comes from use

Here's the part no benchmark captures: the more you use these models, the more you develop a feel for what each one is good at. A genuinely useful habit is to take one prompt and run it across two or three models, then keep the output you like best. Do that enough and patterns emerge, like Gemini's clean visual defaults, Claude's strength in a back-and-forth, one model's knack for gnarly logic. Switching is only ever a dropdown (or a /model command), so you're never locked in and there's no decision to agonize over.

AI Clubhouse · Vibe Coding Guide