The Model Families: GPT, Claude, Gemini, Llama, Qwen, Mistral, DeepSeek

You now understand how foundation models are built. Time to meet the actual players you'll build with. A surprisingly small number of labs produce the models powering nearly everything — and knowing the families (who makes them, open vs closed, what they're good at) is how you make smart choices.

One honest caveat up front: this space moves blisteringly fast. Today's "best model" is dethroned in months; version numbers change constantly. So we'll focus on the families and their positioning — which are reasonably stable — and on how to stay current, rather than asking you to memorize a leaderboard that's already out of date by the time you read it.

You'll learn:

• The two camps: closed (API-only) vs open-weight (downloadable)
• The major closed-frontier families and the major open-weight ones
• The single most important truth: there is no one "best" model
• How to choose — and how to stay current without chasing every release

Every family falls into one of two camps (we'll dig into the tradeoffs in the very next lesson — here, just the map):

• Closed / proprietary — you access them only through an API. The weights are secret. Examples: OpenAI (GPT), Anthropic (Claude), Google (Gemini), xAI (Grok).
• Open-weight — the model's weights are downloadable; you can run, inspect, and fine-tune them yourself. Examples: Meta (Llama), Alibaba (Qwen), Mistral, DeepSeek.

For most application work you'll call an API (closed or a hosted open model), so the practical difference often comes down to control, cost, and privacy — next lesson.

These are the proprietary frontier labs — generally at or near the top of capability, accessed via API.

• OpenAI — GPT (and the reasoning "o"/GPT-5-class line). The most widely known family; broad ecosystem and tooling; strong at agentic and professional work.
• Anthropic — Claude. Known for coding, careful reasoning, safety, and long context — and it's the model this course defaults to (alongside OpenAI). (Fun fact: this very lesson was written with Claude.)
• Google — Gemini. Deeply multimodal (text, images, audio, video), very large context windows, and tight integration with Google's ecosystem.
• xAI — Grok. A newer frontier entrant, often positioned as fast and cost-effective with strong tool-use.

(As of mid-2026, flagship versions are things like Claude Opus 4.x, GPT-5.x, and Gemini 3.x — but treat any specific number as a snapshot; check the provider's site for what's current.)

These you can download and run yourself — and in 2026 the best of them are genuinely competitive with closed models on many tasks (open models have even topped some leading benchmarks).

• Meta — Llama. The family that catalyzed the entire open-weight ecosystem; widely supported everywhere, with some variants offering enormous context windows.
• Alibaba — Qwen. A very strong, fast-moving open family available in many sizes, with excellent multilingual ability.
• Mistral. A European lab known for efficient open models (plus some commercial ones) that punch above their size.
• DeepSeek. A Chinese lab that made waves with highly cost-efficient training and strong open reasoning models — often among the cheapest capable options.

The big shift in 2026: open-weight models are no longer "the budget option" — several rival the closed frontier, which changes the build-vs-buy math (next lesson).

Here's the most important thing to internalize. For the first time, the leaderboard has fractured into lanes — no single model tops every benchmark. As of mid-2026, one family might lead on coding, another on reasoning or data analysis, another on creative writing, another on price.

So "which model is best?" is the wrong question. The right one is "best for what?" — for this task, this budget, this latency requirement.

And they leapfrog constantly: whoever's on top today may be second next month after a competitor's release. Three consequences for how you build:

1. Build provider-agnostic. That's why this course teaches concepts vendor-neutrally and shows Claude and OpenAI — your skills shouldn't depend on one lab.
2. Evaluate on your task. Don't trust headline benchmarks (recall contamination!) — measure candidates on your data (the evals discipline, later).
3. Keep it swappable. Use an abstraction or model router so you can change models in one place. Don't marry one model.

You can't (and shouldn't) chase every release. A sane way to keep up:

• Public leaderboards (e.g., crowd-vote arenas and intelligence indexes) for a rough signal — but read them critically (benchmark contamination, last lesson, inflates numbers).
• Provider announcements for the families you actually use.
• Your own evals — by far the most reliable signal. A model that tops a leaderboard may still be worse on your task.

Think of it this way: the families are the stable map you just learned; the rankings are a fast-moving weather report on top of it. Learn the map once; check the weather when you're about to choose.

Open or closed? From memory, sort these families into open-weight (you can download them) vs closed/API-only:

GPT · Claude · Gemini · Llama · Qwen · Mistral · DeepSeek

→ Open-weight: Llama, Qwen, Mistral, DeepSeek. Closed/API-only: GPT, Claude, Gemini. Knowing which is which decides whether you can self-host (privacy, cost) or must call an API (best frontier quality).

• "There's one best model." No — it's task-dependent and changes monthly. Ask "best for what?"
• "Open models are worse." Not anymore — the top open families now rival closed ones on many tasks (full tradeoffs next lesson).
• "Pick a provider and commit." Risky — stay portable so you can ride the leapfrogging instead of being stuck.
• "Memorize the current rankings." Pointless — they'll be stale fast. Learn the families and lean on your own evals.

• Two camps: closed/API-only (OpenAI/GPT, Anthropic/Claude, Google/Gemini, xAI/Grok) and open-weight/downloadable (Meta/Llama, Alibaba/Qwen, Mistral, DeepSeek).
• Each family has a positioning (e.g., Claude → coding/safety/long-context; Gemini → multimodal; DeepSeek → cheap/reasoning) — but version numbers go stale fast.
• In 2026, open models rival closed ones on many tasks — no single model is best at everything.
• So: build provider-agnostic, evaluate on your task, and keep models swappable — don't marry one.
• Learn the stable family map; check the fast-moving rankings only when you're about to choose.

Next: now that you know who the players are, we weigh the decision you'll actually face — Open vs Closed Models: the tradeoffs of building on each.