Trending LLMs — Market Landscape & How to Keep Up

Reference artifact (a living snapshot — not a 15-section concept doc). Up: References · Related: Phase 0.02 — How to Study Fast-Moving AI · Phase 4 — Model Catalogs

⚠️ Read this first. This page is a dated snapshot (as of June 2026) of the LLM market. Model names, context windows, prices, and rankings change monthly — this page will go stale. The durable parts are the categories, the specs-to-check, the per-use-case picks, and the keep-up system at the end. For current numbers always verify on the primary source (models.dev + the official model card). This page deliberately practices what Phase 0.02 preaches: learn the invariants, track the specifics with a system.

Table of Contents

1. How to read this page
2. The specs that define any model (the columns to compare)
3. The major labs and families (snapshot)
4. Comparison table (snapshot)
5. Open-weight vs commercial — the landscape split
6. Quick picks by use case
7. How to keep up with models, concepts, and terms
8. Cross-references

1. How to read this page

For each family you'll see: who makes it, what it's for, headline specs (open/closed, modality, context, reasoning), best use cases, and a model-card pointer. Treat specific numbers as "go verify", not gospel. Pin a versioned model ID before shipping (Phase 1.08), and run your own eval (Phase 1.07) — leaderboards shortlist, your task decides.

Plain-English reminders (full primer in Phase 1):

• Closed / API-only = you call it over the internet; you can't download it. Open-weight = you can download and self-host it (license permitting).
• Context = how much text it can read at once (in tokens ≈ ¾ word).
• Reasoning model = does hidden step-by-step "thinking" before answering — better on hard tasks, slower, costs more (Phase 2.09).
• Multimodal = handles images/audio/video, not just text (check input vs output separately).
• MoE T-Ak = T total params in memory, ~k active per token (Phase 2.08).

2. The specs that define any model

When you meet any new model, compare it on these axes (this list does not go stale — only the values do):

3. The major labs and families (snapshot)

Snapshot as of 2026-06. Verify current variants/prices on models.dev and the linked cards.

OpenAI — GPT & o-series (closed / API)

• What it's for: general-purpose frontier quality; strong coding, tool use, multimodal; the o-series are dedicated reasoning models.
• Specs: API-only; multimodal (text+image, audio in some variants); large context; reasoning variants expose reasoning_effort.
• Best for: broad products, agents, coding assistants, hard reasoning (o-series).
• Cards/docs: https://platform.openai.com/docs/models · pricing https://openai.com/api/pricing

Anthropic — Claude family (closed / API; also on Bedrock & Vertex)

• What it's for: top-tier coding and agentic work, long-context, enterprise (strong data posture). Tiers: Haiku (fast/cheap) → Sonnet (balanced) → Opus (most capable); extended thinking for hard tasks.
• Specs: API-only; multimodal input; large context; system cards emphasize safety; generally no-train on API data (confirm terms).
• Best for: coding agents, enterprise assistants, tool-use-heavy workflows.
• Cards/docs: https://docs.anthropic.com/en/docs/about-claude/models · system cards https://www.anthropic.com/system-cards · guide → Phase 3.03

Google DeepMind — Gemini (closed / API via AI Studio & Vertex)

• What it's for: natively multimodal (text/image/audio/video/PDF), very large context, thinking variants. Variants: Flash-Lite/Flash (cheap/fast) → Pro (smartest).
• Specs: API-only; strongest at long-context + multimodal ingestion; two access channels (AI Studio vs Vertex) with different governance.
• Best for: multimodal apps, very long documents/video, high-volume cheap tasks (Flash).
• Cards/docs: https://deepmind.google/models/model-cards/ · guide → Phase 3.02

Meta — Llama (open-weight)

• What it's for: the most widely-used open-weight family; self-hosting, fine-tuning, on-prem/private deployment. Dense and MoE variants across sizes.
• Specs: downloadable weights (community license — check commercial terms); huge ecosystem of quantized GGUF/vLLM builds.
• Best for: private/regulated deployments, fine-tuning, cost control at scale, local inference.
• Cards/docs: https://huggingface.co/meta-llama · guide → Phase 3.04

Mistral (open-weight + commercial API)

• What it's for: efficient open-weight models incl. MoE (Mixtral-style); good quality-per-cost; European data option.
• Specs: mix of open-weight and API; MoE variants (total vs active); strong multilingual.
• Best for: cost-efficient self-hosting, European data residency, MoE experimentation.
• Cards/docs: https://huggingface.co/mistralai · https://docs.mistral.ai/

Alibaba — Qwen (open-weight + API)

• What it's for: very strong open-weight models across sizes; excellent coding/math variants; dense and MoE; strong multilingual (esp. Chinese/English).
• Specs: downloadable; many sizes (small enough for laptops to large MoE); reasoning variants (e.g. QwQ).
• Best for: open-weight quality, coding, multilingual, local inference at many hardware tiers.
• Cards/docs: https://huggingface.co/Qwen

DeepSeek (open-weight + API)

• What it's for: large MoE models and strong open reasoning models (R1-style) — frontier-ish quality with downloadable weights.
• Specs: big MoE (high total, modest active params); open reasoning traces you can inspect locally.
• Best for: open-weight reasoning, cost-efficient frontier-class self-hosting (with serious memory).
• Cards/docs: https://huggingface.co/deepseek-ai

Others worth tracking

• Google Gemma, Microsoft Phi (small, capable open models for edge/local), Cohere (enterprise RAG + rerankers/embeddings), xAI Grok, AI21, plus a fast-moving long tail. Embedding/rerank specialists (Cohere, BGE, etc.) matter for RAG (Phase 9).

4. Comparison table (snapshot)

Values omitted deliberately where they churn (exact context/price). Fill them from models.dev the day you decide — and date your note.

5. Open-weight vs commercial

Decision detail in Phase 5; economics in Phase 1.08.

6. Quick picks by use case

Start here, then verify with your own eval — these are starting hypotheses, not verdicts.

7. How to keep up

Models churn; your method shouldn't. Build the system once (full version in Phase 0.02):

A. Separate invariants from specifics. Spend ~80% on the durable stuff (the token loop, attention/KV cache, prefill/decode, cost = tokens × price, eval > benchmarks). Track the rest (which model is "best," exact prices) with a system instead of memorizing.

B. Keep three living files (in your portfolio repo):

• watchlist.md — the 3–5 families above + where each posts releases (changelogs).
• feeds.md — primary sources only (provider changelogs, models.dev, 1–2 high-signal newsletters, an arXiv listing).
• notes-dated.md — facts with an "as of <date>" so staleness is obvious.

C. Use a reliability ladder. Official docs/cards/code > papers > reputable practitioner blogs > social threads (pointers only, never conclusions). Confirm anything decision-relevant at the top of the ladder.

D. Re-verify before every production decision. Prices, rate limits, context windows, and model availability change silently — recheck and pin versioned IDs.

E. Reproduce claims on your task. A "2× faster" or "beats GPT-X" claim is a hypothesis until you run it on your hardware and your eval (Phase 1.07, the Unsloth lesson).

F. Learn the terms once, look up the models forever. New model pages are legible the moment you know the vocabulary — keep the glossary and Phase 1 close. When a new word appears (e.g. a new attention or quantization variant), slot it into the mental model from Phase 2 rather than relearning from scratch.

Monthly 20-minute ritual: skim your feeds.md, update watchlist.md, re-date any changed facts in notes-dated.md, and re-check prices/deprecations for models you run in production.

8. Cross-references

• Vocabulary to read any model page: Phase 1 — LLM Vocabulary (esp. 1.02 params, 1.04 capabilities, 1.08 pricing) + the glossary.
• Mechanisms behind the specs: Phase 2 — Transformer Foundations.
• Reading the cards: Phase 3 — Model Cards & System Cards.
• Comparing in a catalog: Phase 4 — models.dev.
• Choosing for a use case: Phase 5 — Model Selection.
• Keeping up (method): Phase 0.02 — How to Study Fast-Moving AI.

Maintenance note: update this page's snapshot sections (3, 4, 6) on a monthly cadence; the framework sections (2, 5, 7) rarely change. Last snapshot: 2026-06.