Station 2 · The Models
In Station 1 you learned the engine is an LLM. But there isn't one engine — there are dozens, made by different companies, in different sizes. Picking the right one is a builder's first real decision. Let's meet the lineup.
What you'll walk away with
Concept 1
A model is a finished, pre-trained brain. Someone already fed it an ocean of text and spent months (and a fortune) teaching it the patterns of language. What you get is the result of all that training — frozen, ready to use.
Think of a model as a graduate who's already done all their studying. You don't send them back to school — you just hire them and give them work. As a builder, you never train this brain. You call it: you send it text, it sends text back. That's the whole relationship.
A model family is like a console brand — say, PlayStation. Within it there are sizes (a slim vs. a pro edition) and versions over time (PS4 → PS5). A provider works the same way: one family, several sizes for different budgets, and new numbered versions every so often that are smarter than the last. When you hear "GPT-5" or "Claude Opus 4.5," you're hearing family + version.
So three words describe any model you'll meet:
Concept 2
Most builders start with one of three companies. They're called closed providers because you can't peek inside or download their models — you use them over the internet through an API (you'll do exactly this in Station 3).
Here's an honest, high-level read on what each is generally known for. These are broad reputations, not scoreboard rankings — and the picture shifts with every release, so treat it as a starting map, not gospel:
The one that made AI go mainstream. Broad, capable, huge ecosystem and community. Often people's first stop because so many tutorials and tools assume it.
Known for strong writing, careful reasoning, coding, and a big focus on safety. The tiers are named: Opus (largest), Sonnet (balanced), Haiku (fast & small).
Built by Google DeepMind. Known for very large context windows and tight integration with Google's world (Search, Workspace, Android). Strong all-rounder.
For a beginner project, all three are excellent. You won't hit their limits early. Pick one, build, and stay curious — switching later is usually a one-line change.
You'll see "Model X beats Model Y" headlines constantly. They're often true for a week, on one specific test, then flip with the next release. As a builder, the right question isn't "which is #1?" — it's "which is good enough, fast enough, and cheap enough for my project?"
Concept 3
There's a second big split, and it's not about quality — it's about who holds the keys. Some models you can only rent; others you can own.
GPT, Claude, Gemini. They live on the provider's servers. You send requests over an API and pay per use. You get their best models and zero maintenance — but your data leaves your machine and you play by their rules.
Meta's Llama, Mistral, and others. You download the actual model file and run it on your own computer or server. Total control and privacy — but you supply the hardware, setup, and upkeep.
Closed = a rideshare. You don't own anything, you just pay per trip, and a pro handles the maintenance. Fast to start, no garage needed. Open-weight = buying a used car. It's yours, it never leaves your driveway (privacy!), and long trips can be cheaper — but you're now the mechanic, insurer, and gas-buyer. Neither is "better." They fit different lives.
The word is open-weight, not fully "open source." You get the trained brain (its "weights") to run and adjust, but usually not the original training data or the full recipe. Still, being able to download and run a capable model on your own machine — for free, offline, private — is a genuinely big deal.
When open-weight shines: sensitive data that can't leave your building, huge volumes where per-request fees would add up, or just the joy of running AI with no internet at all. When closed shines: you want the strongest possible model, the least setup, and you're fine paying as you go — which is most beginners, most of the time.
Concept 4
Forget leaderboards. Real model choice comes down to four levers you trade off against each other. Learn these and you can choose confidently even for a model that didn't exist yesterday.
You wouldn't take a moving truck to grab a coffee, or a scooter to move apartments. Same with models. A scooter (small/fast/cheap model) is perfect for quick, simple jobs like sorting or short replies. A sedan (medium model) handles most everyday work. A truck (large model) is for the heavy, complex hauls — deep reasoning, tricky code, long documents. Match the vehicle to the trip, not to the brochure.
Notice these levers fight each other. You rarely get smartest + fastest + cheapest all at once. Good builders don't chase the "best" model — they pick the smallest model that comfortably does the job, and only size up when it visibly struggles. That habit alone will save you money and make your projects feel snappy.
And about that context window: it's how much the model can look at in a single request. A small window is fine for chatting. A large window lets you drop in a 50-page PDF and ask questions about the whole thing — which is exactly the trick behind giving AI a memory in Station 5.
Concept 5
Here's the mental picture to lock in: choosing a model isn't just a price setting. Send the identical prompt to three models and you'll get three different-feeling answers.
Why do they differ? Because each model learned from different text, was tuned by a different team with different tastes, and comes in a different size. So they develop distinct "personalities" — one more concise, one more thorough, one warmer in tone. None is objectively "correct"; they're just different drivers of the same kind of engine.
# A builder's rough rule for choosing — plain-English pseudocode function pickModel(job): if job.needs_privacy or job.runs_offline: return "open-weight (Llama / Mistral) — run it yourself" if job.is_simple and job.high_volume: return "a small, fast model — the scooter" # cheap + quick if job.needs_deep_reasoning or job.is_long: return "a large model — the truck" # smart + big context return "a medium model — the sedan" # the safe default # Start with the sedan. Size up only when it struggles.
A model is a pre-trained brain you rent (closed) or run (open-weight). You don't pick the "best" one — you match four levers (smarts, speed, price, context) to your job, start small, and size up only when needed.
Checkpoint
You're building a tool that sorts thousands of short customer messages into "happy / neutral / upset" every hour, on a tight budget. Which model fits best?
Sorting short messages into three buckets is a simple, repetitive job — it doesn't need deep reasoning. Since you're running it thousands of times an hour on a budget, speed and low cost per request matter most. That's a textbook "scooter" job: pick a small, fast model and save the big, pricey one for the genuinely hard problems.
Try it yourself — 15 minutes, no code
The best way to feel the differences is to test them side by side. Open ChatGPT, Claude, and Gemini (all have free tiers) in three tabs.
Keep: note which model you personally liked best and why. There's no wrong answer — the point is that you now have an opinion, which is exactly how builders choose.
Recap. A model is a pre-trained brain — you build on it, you don't build it. The big three closed providers (OpenAI's GPT, Anthropic's Claude, Google's Gemini) are all beginner-friendly and rented through an API, while open-weight models like Llama and Mistral trade convenience for control and privacy. And you don't pick the "best" model — you match four levers (smarts, speed, price, context window) to the job, start with a sedan, and size up only when it struggles. Next station, you'll stop chatting in a browser and actually call one of these models with code.