The 2026 AI Model Landscape

On July 15, 2026, Thinking Machines Lab released Inkling, its first flagship model, alongside a preview of a smaller sibling called Inkling-Small. This is arguably the single most closely watched model launch of the year — not because Inkling tops every leaderboard (it doesn't), but because of who built it, how fast they built it, and the strategic bet embedded in how they're releasing it.

The Mira Murati story

Mira Murati served as OpenAI's Chief Technology Officer through some of the company's most consequential years, including the launch of ChatGPT and GPT-4. She departed OpenAI in September 2024, one of a wave of senior departures from the company that year. Rather than joining an existing lab, Murati set out to build her own — founding Thinking Machines Lab in February 2025 alongside John Schulman, a co-founder of OpenAI and one of the primary architects of the RLHF (reinforcement learning from human feedback) techniques that made ChatGPT possible, and Lilian Weng, another high-profile OpenAI alum known for her widely-read technical writing on agents, diffusion models, and safety.

The founding team's pedigree let Thinking Machines Lab raise an unusually large seed round: $2 billion at a $12 billion valuation, led by a16z, with participation from Accel, Nvidia, and AMD — notably, two of the largest chip makers in the world backing a model lab directly — plus Jane Street, a proprietary trading firm with deep quantitative and infrastructure expertise. This is one of the largest seed rounds in technology history, reflecting investor confidence that a team with this specific combination of research and engineering leadership could execute quickly.

Thinking Machines Lab is structured as a public benefit corporation (PBC), a legal structure that allows the company to weigh public benefit alongside shareholder returns in its decision-making — a structure Anthropic and OpenAI's nonprofit-adjacent structures have popularized in the AI industry as a way to signal mission alignment to employees, regulators, and the public without fully forgoing commercial upside.

Architecture deep dive

Inkling is a Mixture-of-Experts model with 975 billion total parameters, of which only 41 billion are active for any given token — a sparsity ratio in line with other leading MoE systems (see Module 3 for the general mechanics). It was trained on 45 trillion tokens spanning text, image, audio, and video, making it multimodal from the ground up rather than through post-hoc adapter layers.

The most technically distinctive choice in Inkling's design is that it is encoder-free for two of its modalities. Most multimodal models pair a language model backbone with a separate pretrained encoder for each additional modality — a CLIP-style vision encoder for images, a Whisper-style encoder for audio — and then project those encoder outputs into the language model's embedding space. Inkling instead represents audio as discrete dMel spectrograms (a discretized mel-spectrogram tokenization scheme) and images as raw 40x40 pixel patches, feeding both directly into the same token stream the language model already processes. This removes an entire class of architecture (the modality-specific encoder) and lets a single unified transformer/MoE stack learn cross-modal relationships end-to-end.

This is a meaningful bet: encoder-free multimodal architectures are harder to train stably (there's no pretrained encoder doing representation-learning heavy lifting up front) but can, in principle, capture cross-modal correlations that encoder-based approaches structurally cannot, because nothing is lost in a lossy encoder bottleneck before the main model even sees the data.

Inkling supports a 1 million token context window and offers controllable thinking effort — a user- or API-exposed parameter that trades inference latency and cost for deeper chain-of-thought reasoning, similar in spirit to reasoning-effort controls in other 2026 frontier models (see Module 7).

Benchmark performance

Inkling's benchmark profile paints a consistent picture: strong, broadly competent, but not the outright leader on the hardest agentic coding and terminal-use benchmarks.

Two comparisons from launch week are worth calling out explicitly because they defined the honest competitive positioning of the model. On SWE-Bench, Inkling's 77.6% trailed Claude Fable 5's 95.0% by a wide margin — nearly 18 points — which matters enormously for anyone evaluating models specifically for autonomous coding agents. On Terminal-Bench, GPT-5.6 Sol's 89.5% versus Inkling's comparatively weaker showing (63.8% in the data available) told a similar story: for pure terminal-driving agentic tasks, the closed frontier labs still had a clear edge. Since July the goalposts have moved again: Terminal-Bench 4.0 has replaced 2.1 as the headline agentic benchmark (Claude Opus 5.5 reports 66.4% and Sonnet 5.5 70.6% on it), the closed labs have each shipped a new generation, and Thinking Machines Lab has not published updated Inkling numbers — so treat the table above as a July snapshot. Module 5 has the October picture.

Where Inkling actually wins: adaptability

Thinking Machines Lab has been explicit and consistent in its own positioning: Inkling is "not the strongest, but the most adaptable." This is a deliberate strategic choice rather than a consolation prize, and it rests on two pillars.

The first pillar is the Tinker platform, Thinking Machines Lab's customization and fine-tuning offering built specifically around Inkling. Tinker is designed to make it straightforward for a team to adapt Inkling's weights to a specific domain, style, or task distribution without needing the enormous infrastructure typically required for large-model fine-tuning. Because Inkling is fully open-weight, Tinker can operate directly on the underlying parameters rather than working through the constrained fine-tuning APIs that closed labs expose.

The second pillar is distribution. Inkling shipped simultaneously on HuggingFace, Together AI, Fireworks, Modal, Databricks, and Baseten — essentially every major inference and MLOps platform that serious AI teams already use. This is a stark contrast to a typical closed-model launch, which is usually API-only and single-vendor at first. It signals that Thinking Machines Lab is optimizing for "meet developers wherever they already are" rather than building a walled garden.

For lighter interactive use, Thinking Machines Lab also offers the Inkling Playground, a hosted chat interface comparable to ChatGPT or Claude.ai, aimed at less technical users who want to try the model without touching an API or downloading weights.

The open-weights strategic bet

Releasing a 975-billion-parameter model with open weights under Apache 2.0 is a significant strategic choice with real trade-offs. On one hand, it forgoes the ability to charge premium API-only pricing the way Anthropic and OpenAI do for their top-tier models. On the other hand, it builds enormous developer goodwill and distribution reach immediately, and it makes the Tinker fine-tuning business model viable — you can't sell customization tooling for a model people can't touch.

It also positions Thinking Machines Lab favorably against regulatory headwinds. As discussed in Module 10, open-weight models receive certain exemptions and lighter-touch treatment under frameworks like the EU AI Act relative to closed frontier systems, even though core obligations around copyright and training-data transparency still apply to everyone.

What Inkling means for the rest of the industry

Inkling's existence changes the calculus for every other lab in a few concrete ways. It proves that a team of roughly a few hundred people, operating for about 18 months, can produce a model within striking distance of the frontier on many axes — compressing what used to be considered a multi-year, thousand-person undertaking. It adds a credible, Western, well-capitalized, open-weight competitor to a category that had been dominated by Chinese labs (GLM, Qwen, DeepSeek, Kimi) and Meta. And it puts pressure on Anthropic and OpenAI specifically, given the founders' direct lineage from OpenAI — this is in some sense "the OpenAI alumni model," and its performance and adoption will be read by the market as a referendum on how much of frontier model capability lives in institutional knowledge that walks out the door with senior researchers.

Inkling-Small and the roadmap beyond launch day

Alongside the flagship Inkling release, Thinking Machines Lab previewed Inkling-Small, a lighter-weight sibling aimed at the same use cases as the small/efficient model category discussed in Module 8: local deployment, lower-latency applications, and cost-sensitive high-volume workloads where the full 975B/41B-active flagship would be overkill. Launch coverage put Inkling-Small at 276 billion total parameters with 12 billion active (about 4.3% active, in line with the flagship's sparsity), with text, image and audio input and the same 1M-token context, and later July reporting listed it on Hugging Face and in Tinker. Its existence signals a deliberate multi-tier product strategy rather than a single-model release — mirroring the tiered approach every other major lab (Claude's Fable/Opus/Sonnet/Haiku ladder, OpenAI's Astra/Sol/Luna ladder) has already converged on.

The company has also signaled that Tinker and the Inkling Playground will continue to receive iteration independent of the base model itself, treating the surrounding tooling as a first-class product rather than a thin wrapper around the weights. For teams evaluating Inkling, this means the honest comparison point isn't just "Inkling vs. GLM-5.2 on a benchmark table" — it's "Inkling plus Tinker's fine-tuning workflow vs. whatever customization path a competing open-weight model offers," which is a fundamentally different, and for many teams more relevant, comparison.

If there is one architectural decision that defines the 2026 model landscape more than any other, it is the near-total industry shift toward Mixture-of-Experts (MoE) architectures. Over 60% of open-source AI releases in 2026 use MoE, and every model in Module 1's comparison table with a disclosed architecture other than the very smallest edge models is either MoE or MoE-adjacent. Understanding how MoE works — and why it won — is essential to understanding everything else in this course.

The core idea: sparse activation

A traditional "dense" transformer uses every one of its parameters to process every token. If you have a 70-billion-parameter dense model, generating a single token requires computation that touches all 70 billion parameters. This is simple and has been the default architecture for most of the history of large language models, but it means model size and inference cost are locked together: to get a bigger, more capable model, you must pay for proportionally more compute on every single token you generate, whether or not that token actually needed all that capacity.

MoE breaks this coupling. Instead of one enormous feed-forward network that every token passes through, an MoE layer contains many smaller "expert" networks — often 8, 16, 64, or more — plus a small gating network, also called a router. For each token, the router looks at that token's representation and decides which small subset of experts should process it. A common configuration is top-2 routing with 8 experts, meaning each token is sent to just 2 of the 8 available experts — only 25% of the expert parameters are actually activated for that token, even though all 8 experts' weights exist and were trained.

How the router actually works

Mechanically, the gating network is typically a small linear layer followed by a softmax (or a similar normalization) that takes the incoming token's hidden-state vector and produces a score for each expert. The top-k experts by score are selected — in top-2 routing, the two highest-scoring experts. The token is processed by both selected experts, and their outputs are combined, usually as a weighted sum using the router's own scores as weights. This means the router isn't just picking experts, it's also learning how much to trust each one for a given token.

Crucially, this routing decision is learned end-to-end along with everything else during training. Nobody hand-assigns "this expert handles math, this expert handles poetry." In practice, researchers observe experts specializing along various axes — sometimes semantic (a cluster of experts that activate heavily for code), sometimes more diffuse and harder to interpret — but the specialization emerges from gradient descent, not from design.

Why this makes both training and inference cheaper

The efficiency gains from MoE are substantial and well-documented across 2026's major releases. Compared to an equivalently capable dense model, well-tuned MoE architectures deliver up to 70% lower computation per token, roughly 10x faster inference in production serving conditions, and about one-tenth the cost per token generated. This is the single biggest reason API pricing across the industry has fallen 60-80% since early 2025 (see Module 9) — it is far cheaper to serve a 975B-total/41B-active MoE model than it would be to serve a dense 975B model, even though the MoE model may match or exceed the dense model's quality on many tasks.

The training-side economics are more nuanced. You still need to store, checkpoint, and update the gradients for all the experts, including ones a given batch of data rarely routes to — so MoE doesn't proportionally reduce training compute the way it reduces inference compute. But it does let a lab reach a higher total-parameter, higher-capacity model within a fixed training compute budget, which is why virtually every lab racing for larger effective model capacity in 2026 has adopted MoE rather than continuing to scale dense architectures.

The MoE roster in 2026

Notice the pattern: active-parameter ratios across the industry cluster between roughly 4% and 6.5% — and the August–October wave of releases (Hy4, Mistral Large 4, MiMo-V2.6, Beam) landed inside the same band. This isn't a coincidence — it reflects a fairly convergent understanding among researchers of the sweet spot between "enough active capacity per token to reason well" and "sparse enough to get the cost benefits that justify going MoE in the first place." The one outlier, Gemma 4's 26B MoE at roughly 15% active, is the exception that explains the rule: at 26B total there is simply less to be sparse about, and Google's goal there was fitting a workstation GPU, not minimizing serving cost at hyperscale.

Training challenges that don't show up in the marketing

MoE is not free complexity. Labs that have shipped production MoE systems consistently report two recurring failure modes.

Expert collapse occurs when the router learns to favor a small subset of experts disproportionately, starving the rest of training signal. Once an expert receives little gradient update, it tends to stay unattractive to the router (because it never improves), reinforcing the imbalance in a vicious cycle. Left unaddressed, a model can effectively degrade toward using only a handful of its many experts, wasting most of the parameter budget it was trained with.

Load imbalance is the systems-engineering sibling of expert collapse. Even short of full collapse, if some experts are routed to far more often than others, the GPUs or TPUs hosting the popular experts become bottlenecks while the ones hosting rarely-used experts sit idle — a serious problem in distributed training and serving where experts are typically sharded across many devices.

Both problems are commonly addressed with auxiliary load-balancing losses added to the training objective, which penalize the model for uneven routing distributions, alongside capacity limits that simply drop or reroute tokens once an expert's per-batch capacity is exceeded. A third, subtler challenge is communication overhead: because experts are sharded across devices in large-scale training, routing a token to an expert on a different device requires an all-to-all communication step, which can dominate wall-clock training time if not carefully optimized with high-bandwidth interconnects and clever batching.

When MoE beats dense — and when it doesn't

MoE's advantages are largest when you want maximum capability at a given inference budget, and you have enough training data and compute to justify a very large total parameter count. This describes essentially every frontier lab in 2026. MoE is less obviously advantageous for small models — an edge model like Gemma 4 E2B, meant to run entirely on a phone with 6GB of RAM, gains little from MoE's sparsity trick, because the entire point is to keep total memory footprint small, and MoE's efficiency gain comes precisely from having a large total parameter pool you don't fully activate. For genuinely small models, dense architectures paired with aggressive quantization (Module 8) remain the more practical choice — which is why Gemma 4's E2B, E4B and 12B are dense and only its 26B workstation tier is MoE.

Deploying an MoE model with vLLM

In production, MoE models are typically served with inference engines that have been specifically optimized for sparse expert routing, expert parallelism across GPUs, and efficient batching. vLLM is the most widely adopted open-source engine for this in 2026, with native support for expert-parallel serving of models like Llama 4, Qwen3, DeepSeek, and Mixtral-family architectures.

# Install vLLM with MoE / expert-parallel support
# pip install vllm

from vllm import LLM, SamplingParams

# Load an MoE model with tensor + expert parallelism across 4 GPUs.
# vLLM automatically detects the MoE architecture from the model config
# and shards experts across the available devices.
llm = LLM(
    model="meta-llama/Llama-4-Maverick",
    tensor_parallel_size=4,
    enable_expert_parallel=True,   # route experts across GPU shards
    max_model_len=32768,
    gpu_memory_utilization=0.90,
    dtype="bfloat16",
)

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=1024,
)

prompts = [
    "Summarize the trade-offs between dense and MoE architectures "
    "for a team deciding how to serve a 400B-parameter model."
]

outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(output.outputs[0].text)

# Notes:
# - enable_expert_parallel splits experts (not just layers) across GPUs,
#   which reduces per-GPU memory pressure for very large MoE models.
# - Only "active" experts contribute to the forward pass per token, so
#   observed inference latency tracks the active-parameter count, not
#   the total parameter count, even though all experts occupy VRAM.
# - For multi-node serving of models like Inkling (975B total / 41B
#   active) you would additionally configure pipeline_parallel_size
#   and a high-bandwidth interconnect (NVLink/InfiniBand) between nodes.

MoE versus other sparsity and efficiency techniques

It's worth situating MoE against other efficiency techniques it's sometimes confused with. Quantization (covered in depth in Module 8) reduces the numerical precision of every weight uniformly and is orthogonal to MoE — you can and often do quantize an MoE model's experts, stacking both techniques for compounded savings. Pruning removes individual weights or whole neurons deemed unimportant after training, a static, one-time compression step, whereas MoE's sparsity is dynamic and input-dependent, decided fresh for every token at inference time. Speculative decoding, another popular 2026 efficiency technique, uses a small draft model to propose multiple tokens that a larger model then verifies in parallel — this speeds up generation latency without touching parameter count or architecture at all, and is also commonly layered on top of MoE-served models for additional throughput gains. Understanding that these techniques are complementary rather than competing is important: a well-optimized 2026 production deployment of a model like Inkling or GLM-5.2 will typically combine MoE's architectural sparsity, aggressive quantization of the active experts, and speculative decoding at the serving layer simultaneously.

A brief history: how MoE went from research curiosity to default

Sparse mixture-of-experts layers have existed in the machine learning literature since well before the current generation of large language models, but they remained a research niche through most of the 2010s due to the engineering difficulty of efficiently routing and parallelizing token-to-expert assignment at scale. The technique moved from curiosity to production reality only once distributed training infrastructure matured enough to handle the all-to-all communication patterns MoE requires without that communication overhead swamping the compute savings. By 2023-2024, several labs had demonstrated MoE models matching or exceeding dense models of similar active-parameter budgets, and by 2026 the pattern has fully inverted: it would now be unusual, not innovative, for a lab targeting frontier-adjacent total capability to choose a dense architecture over MoE, barring a specific reason (like targeting extreme edge-device deployment) to prioritize total memory footprint over total capacity.

Open-weight models — models whose trained parameters are published for anyone to download, run, and in most cases fine-tune — have gone from a curiosity to a genuine parallel ecosystem to frontier closed models. This module walks through every major family in detail, because the differences between them (architecture, license, language coverage, intended use case) matter enormously once you're actually choosing one to deploy.

Inkling (Thinking Machines Lab)

975B / 41B active Apache 2.0

Covered in full in Module 2. The headline Western open-weight release of 2026: a 975B-total, 41B-active MoE model with encoder-free native multimodality (dMel spectrograms for audio, 40x40 pixel patches for images), a 1M token context window, and controllable thinking effort, released under Apache 2.0 with a 276B/12B-active Inkling-Small alongside. Available across HuggingFace, Together AI, Fireworks, Modal, Databricks, and Baseten, with the Tinker platform for fine-tuning. Positioned explicitly as "not the strongest, but the most adaptable": at launch it trailed Claude Fable 5 on SWE-Bench (77.6% vs 95.0%) and GPT-5.6 Sol on Terminal-Bench, but led on cost of customization and breadth of distribution. No major Inkling update has shipped since July.

GLM-5.2 and GLM-5.3 (Zhipu AI)

750B / 40B active GLM-5.2: MIT GLM-5.3: conditional license

Widely regarded heading into mid-2026 as the strongest all-round open-weight model, GLM-5.2 is a 750-billion-parameter MoE model with 40 billion active parameters and a 1 million token context window. Its MIT license is about as permissive as open-source licensing gets — no field-of-use restrictions, no attribution requirements beyond standard MIT terms, full commercial use permitted. Zhipu AI (also known internationally as Z.ai) has built a reputation for consistently shipping close to state-of-the-art open-weight performance on general reasoning and coding benchmarks, and GLM-5.2 continues that trend. For teams wanting maximum legal simplicity alongside frontier-adjacent capability, GLM-5.2 is still the default recommendation.

GLM-5.3 changed the license, not just the model. Z.ai opened GLM-5.3 through its API on August 14 and published the weights on August 28 after a two-week safety hold: about 744B total parameters (Hugging Face's header says 753B) with 40B active. Instead of MIT it ships under a new GLM-5.3 License that, per launch reporting, requires companies above $10 billion in revenue to complete a security review with Z.ai — sources disagree on whether that threshold means total revenue or model-as-a-service revenue, and the full license text was not in the coverage we could verify. The smaller GLM-5.3 Flash is listed as MIT. The practical rule: for most organizations GLM-5.3 is as free to use as 5.2 was, but hyperscale providers now have a gate, and anyone writing "MIT" into a procurement document should re-check which GLM version they mean.

Llama 4 (Meta)

Maverick: 400B MoE Scout: 10M context Llama Community License

Meta's Llama 4 family ships in two primary configurations. Maverick is a 400-billion-parameter MoE model tuned for general-purpose capability. Scout trades some raw parameter count for an extraordinary 10 million token context window, making it the go-to choice within the Llama family for tasks involving enormous documents, codebases, or multi-document synthesis that would exceed the context limits of nearly every other model on the market. The Llama Community License is not a true open-source license by OSI standards — it includes restrictions (notably requiring large companies above a certain monthly active user threshold to obtain a separate commercial license from Meta) — but it remains free and unrestricted for the overwhelming majority of developers and companies. Llama's biggest advantage is ecosystem maturity: more fine-tuning tooling, more community documentation, and more enterprise vendor support has been built around Llama than almost any other open-weight family, simply because it's been around longest at scale. Note where Meta's own attention has gone, though: its frontier work now ships as the closed Muse Spark line (Muse Spark 1.3 arrived September 2 at $1.25/$4.25 per Mtok), and its newest open release is Muse Glimmer, a 30B model distilled from Muse Spark and published under Apache 2.0 — no monthly-active-user clause at all. Weights for Muse Spark 1.2 have been promised without a date. Llama 4 remains Meta's open line of record, but it is no longer where Meta's newest capability lands first.

Gemma 4 (Google)

E2B / E4B / 12B / 26B MoE / 31B dense Apache 2.0

Gemma 4 is Google's answer to "what if the open-weight model was designed for phones and laptops, not data centers." The family launched on March 31, 2026 — the first Gemma under Apache 2.0 rather than Google's custom license — in four sizes: E2B (2.3B effective parameters) and E4B (4.5B effective) for phones and single-board computers with a 128K context, a 26B mixture-of-experts model with 3.8B active parameters, and a 31B dense model, the latter two with 256K context and video input. A 12B dense model was added on June 3, 2026 (the "Gemma 4 12B Unified" release in Google's changelog): 256K context, encoder-free multimodality, and a 16 GB memory footprint that makes it the laptop sweet spot between E4B and the 26B MoE. E4B reaches 69.4% on MMLU-Pro while remaining small enough to run on a smartphone with 4-bit quantization, and E2B is tuned for Android devices, achieving 10-25 tokens per second on a Pixel 9 Pro. No Gemma 4.x point release has followed; Google's only Gemma addition since June is EmbeddingGemma 2 (October 6). See Module 8 for hands-on local deployment details.

Qwen 3.5 / 3.8 (Alibaba)

Qwen3.8-Max: 2.4T Qwen3.8-27B dense 27B: Apache 2.0 Max: license unclear

Alibaba's Qwen family has become one of the most respected open-weight lines specifically for reasoning-heavy tasks; the Qwen 3.5 generation's 235B-total/22B-active MoE configuration ("235B-A22B" in Qwen's own naming shorthand) delivered strong math, code, and logic performance under Apache 2.0, and Qwen's standout differentiator remains language coverage (201 languages), making it the strongest open-weight choice by a wide margin for multilingual applications, particularly for lower-resource languages that most Western labs undertrain.

The Qwen 3.8 generation arrived in August at two very different scales. Qwen3.8-Max, unveiled August 2, is a 2.4-trillion-parameter model whose weights followed within a week — the second-largest open-weight model after Kimi K3 — but the open checkpoint is narrower than the API model (text in, text out, without the full 1M-token context) and its license terms were not clearly documented in the release materials, so treat it as "downloadable" rather than "Apache 2.0" until you have read the license file. Qwen3.8-27B (August 14) is the opposite bet: a 27B dense model under Apache 2.0 with a 262K native context, text, image and video input, and a vendor-reported 61.7% on SWE-bench Pro — the checkpoint that fits ordinary on-premise GPU hardware, and the base that Cloudflare's Clef decision model was reportedly built on. Alibaba's API-only Qwen3.8-Omni-Flash (September) rounds out the line: text, image, audio and video in, 1M context, $0.15/$0.47 per Mtok, pitched at agents.

DeepSeek V4 (DeepSeek)

Reasoning specialist MIT License Prices raised Aug 17

DeepSeek built its brand specifically around reasoning capability delivered at extremely low cost — DeepSeek V4 continues the lineage established by DeepSeek-R1 (Module 7) of using reinforcement-learning-heavy training to produce strong chain-of-thought reasoning without the largest possible parameter count, and MIT licensing plus famously aggressive pricing (V4 Flash was priced around $0.14 per million tokens before August) made it a default choice for cost-sensitive reasoning workloads at very high request volumes.

Then the pricing turned. On August 6 DeepSeek warned of a "significant" increase, and on August 17 V4 Pro and V4 Flash API prices rose by 50% to 1,100% depending on model, token type and time of day, with new peak and off-peak tiers — V4 Pro output went from $0.87 to $3.96 per million tokens at peak, about 4.5x. The stated reason was demand outpacing capacity, and the result, as reported by The Information in late September, was an annualized revenue run rate above $1 billion (more than double the figure from a few months earlier) after rises of roughly 2.3–4.5x on the headline tiers, with customers largely staying. DeepSeek is reportedly raising about ¥50 billion (roughly $7.5 billion) at a ¥500 billion valuation, targeted to close by the end of October. The lesson for buyers is that "cheap inference" was a pricing decision, not a property of the weights: the MIT-licensed weights are still free to self-host, which is exactly the hedge the open-weight category is supposed to provide, but anyone who built unit economics on DeepSeek's hosted API in July should re-run them against the peak/off-peak table.

Mistral Large 4 / Large 3 / Small 4 (Mistral AI)

Large 4: ~1T MoE, 49–52B active (reported) Large 3 / Small 4: Apache 2.0 Large 4 weights due late October

Mistral remains Europe's flagship AI lab and the closest thing to a European "national champion" in the model landscape. Mistral Large 3 targets general frontier-adjacent capability, while Mistral Small 4 targets efficient deployment. The family's language coverage (80+ languages) and Apache 2.0 licensing make it a common default for European enterprises navigating GDPR and EU AI Act compliance who want a model developed under EU jurisdiction from the outset (see Module 10).

Mistral Large 4, which entered public preview on October 6 through Mistral's hosted API, is the lab's first trillion-parameter model and its re-entry into the frontier-adjacent tier: a mixture-of-experts design of roughly 1T total parameters (Mistral's documentation reportedly lists 1.05T) with active parameters given as 49B in launch coverage and 52B in later documentation. Mistral describes it as open-weight, but as of this refresh it is a hosted preview; the weights are promised later in October, with October 27 reported as the date, and the license will only be known when they land. Every benchmark published so far is Mistral's own, and the lab itself positions Large 4 against other open models rather than against the closed frontier. If the weights arrive on schedule under a permissive license, Large 4 becomes the largest Western open model after Inkling and the obvious EU-jurisdiction candidate for teams that need more than Large 3 — until then it belongs in the "announced, verify on release" column.

Phi-4 (Microsoft)

14B dense MIT License

Covered in depth in Module 8. A 14-billion-parameter dense model achieving 84.8% on MMLU while fitting comfortably on a single 12GB consumer GPU, MIT licensed. Phi-4 is Microsoft's proof point that careful data curation and training methodology can substitute for raw parameter count, and it remains one of the most efficient "quality per parameter" models on the market.

Kimi K3 (Moonshot AI)

MoE, largest open-weight model available

Moonshot AI's Kimi K-series positioned itself as a coding specialist among open-weight MoE models, competing with Qwen3-Coder and DeepSeek for developer mindshare. The K2.6/K2.7 line continued that incremental cadence — and then Kimi K3 changed the category.

Moonshot released K3's weights publicly on July 26, 2026: 2.8 trillion parameters with a 1M-token context window, making it the largest open-weight model publicly available by a wide margin. Together AI and Modal both announced day-zero hosted access timed to the drop, so you can evaluate it without owning the hardware. As of October 13 it is still the largest: Qwen3.8-Max (2.4T) is the closest, with Mistral Large 4 (~1T) and Tencent's Hy4 (770B) behind it, and Reflection AI's own launch materials for Beam concede that K3 remains ahead on raw capability.

The catch is inference economics. The weights are roughly 594 GB in native MXFP4 format, and up to 1.4 TB depending on quantization — the official Hugging Face repository ships 96 weight shards alongside the Kimi K3 License and deployment configs. "Open weights" here does not mean "runs on your workstation"; it means a well-funded team can self-host a frontier-adjacent model without vendor permission. That is a meaningful strategic difference, but the capital requirement is real.

The release also landed squarely in the open-weights policy debate. Anthropic CEO Dario Amodei addressed it directly, saying Anthropic "has never advocated for a ban on open-weights models" and describing non-dangerous open models as "a public good," while continuing to push for chip export controls, anti-distillation enforcement, and mandatory safety testing.

Tencent Hy4-preview

770B / 49B active Apache 2.0

Tencent open-sourced Hy4-preview on August 28: a 770-billion-parameter mixture-of-experts model activating 49 billion parameters per token (about 6.4%, slightly above the industry band), with a 1M-token context window, Apache 2.0 licensing, and weights on Hugging Face, GitHub, ModelScope and GitCode. Reporting describes 78 layers, the first dense and the remaining 77 routed, and frames it as a doubling of both figures from its Hy3 predecessor (295B / 21B active). Tencent Cloud lists hosted pricing near $0.83/$2.50 per million tokens. Tencent's benchmark claims — including an internal, expert-graded engineering evaluation placing it slightly ahead of GLM-5.3 and Kimi K3 — are vendor-reported and unreproduced, and the "preview" label is Tencent's own. What makes it notable regardless is the license: a 770B Apache 2.0 model with 1M context from a hyperscaler is the kind of release that, a year ago, would have been the headline of the quarter rather than one entry in a busy month.

Xiaomi MiMo-V2.6

Flash: 309B / 15B active Native multimodal MIT License

Xiaomi released and open-sourced the MiMo-V2.6 series on September 22: MiMo-V2.6-Pro and MiMo-V2.6-Flash, both native multimodal models accepting text, image, video and audio with a 1M-token context, plus a 9B checkpoint distilled from Qwen3.5-9B on MiMo-generated data. Flash is a sparse MoE of 309 billion total and 15 billion active parameters (about 4.9%), listed on OpenRouter at $0.14/$0.28 per million tokens — close to what DeepSeek used to charge, and now one of the cheapest 1M-context multimodal options with open weights. The release shipped weights, a technical report, training environments and reinforcement-learning code together under MIT. Xiaomi's reported Artificial Analysis index score for Pro (46.32) is vendor-cited; the point for a buyer is that a phone maker just published an MIT-licensed, trillion-token-context multimodal MoE, which says something about how commoditized the recipe has become.

Cloudflare Clef and Clef-flash — "decision models"

27B / 9B dense Typed answers, not text Apache 2.0 (weights)

Cloudflare's October 1 release is a different kind of open model. Clef (27B, 64K context) and Clef-flash (9B) take an input state plus a schema of typed questions and return probabilities over each allowed answer — no generated text, no reasoning trace, millisecond-class latency. Cloudflare suggests ticket routing, request blocking and escalation decisions, and hosts both on Workers AI at $0.24 and $0.09 per million input tokens; the weights are on Hugging Face under Apache 2.0, and the API is compatible with TypeSafe AI's Jev decision-model interface. Two caveats: Cloudflare calls them open-source, but confirmed to The Register that the training data is not public, so they are open-weight; and the benchmark and latency figures are self-reported and inconsistent across secondary coverage. The category matters more than the numbers. A large share of what agent loops do is gating and routing, and a fast classifier with a schema is often the right tool for those steps rather than a chat model. Module 7 returns to this.

Reflection AI Beam (announced, weights pending)

501B / 23B active Apache 2.0 promised

Reflection AI announced Beam on October 5: a text-only sparse MoE with 501 billion total and 23 billion active parameters (about 4.6%), a 1M-token context, built for enterprise coding and agentic workloads. Early access is by waitlist, and the published weights, technical report, model card and Apache 2.0 license are promised before the end of October, with FP8 and NVFP4 quantized versions. Reflection claims Beam matches GLM-5.2 on advanced reasoning at 3–4x less inference compute while acknowledging Kimi K3 remains ahead on raw capability; none of this is independently verified yet. Beam is this quarter's instance of the founder-led-lab pattern Module 10 discusses — a new lab whose first release is a frontier-adjacent open-weight MoE — and the right posture is the same as for Mistral Large 4: evaluate when the weights land.

Nemotron 3 Super (NVIDIA)

Dense/MoE hybrid

NVIDIA's Nemotron 3 Super line is notable less for topping benchmarks and more for what it represents strategically: NVIDIA, as the dominant supplier of the GPUs everyone else trains and serves models on, has increasingly opened its own training resources, recipes, and tooling alongside the model itself. This makes Nemotron a useful reference implementation for teams who want to understand or replicate NVIDIA's own training pipeline rather than treating the model purely as a black-box download.

Comparing licenses at a glance

Choosing between them

For maximum legal simplicity with frontier-adjacent capability: GLM-5.2 (MIT), or Inkling and Hy4 under Apache 2.0 — not GLM-5.3 if you are above its revenue threshold. For the largest possible context window on genuinely enormous documents: Llama 4 Scout. For multilingual coverage: Qwen 3.5/3.8. For cheap, strong reasoning at scale: DeepSeek V4 self-hosted (its hosted API is no longer the bargain it was) or Xiaomi MiMo-V2.6 Flash. For on-device/edge deployment: Gemma 4 E2B/E4B/12B or Phi-4. For a single-GPU-box dense model with a permissive license: Qwen3.8-27B. For maximum fine-tuning adaptability with a well-funded platform behind it: Inkling via Tinker. For coding-specific workloads: Kimi K3 (if you can serve 2.8T parameters) or Qwen3.8-27B. For routing, triage and gating steps that need a typed answer in milliseconds: Cloudflare Clef. There is rarely a single "best" open-weight model — the right choice is a function of your license constraints, your context length needs, and your deployment target.

The community and tooling ecosystem around open-weight models

A model's raw weights are only part of what makes it usable in practice. HuggingFace remains the central hub where nearly every open-weight family in this module gets published, discussed, and iterated on by the community — quantized variants, fine-tuned derivatives, and evaluation harnesses for a given base model typically appear within days of release. Inference platforms like Together AI, Fireworks, Modal, Replicate, and Baseten compete on serving these models with optimized latency and pricing, effectively turning open weights into a commodity API experience without requiring self-hosting. And a rich derivative ecosystem has grown up around the most popular base models specifically — community fine-tunes of Llama and Qwen models for narrow domains (legal document review, customer support, creative writing in specific styles) number in the tens of thousands on HuggingFace alone, illustrating that the value of an open-weight release compounds well beyond the original lab's own roadmap once the community starts building on it.

This ecosystem effect is itself a selection criterion. A newer entrant like Inkling starts with less of this derivative ecosystem than a multi-year-mature family like Llama, even if its base capability is competitive — for teams that rely heavily on community fine-tunes or third-party tooling rather than building their own, ecosystem maturity can be as important a factor as raw benchmark scores.

Despite the rapid rise of open-weight competitors, the four major closed labs — Anthropic, OpenAI, Google, and xAI — retain a clear edge on the hardest agentic and reasoning tasks in October 2026. This module covers each family and the pricing trade-offs between tiers, as they stand after the busiest ten weeks the closed frontier has had: every one of the four labs shipped a new generation between September 1 and October 13, and three of them cut prices doing it.

How we got here: the July picture

When this course was first written, the closed frontier looked like this. Anthropic's lineup was Claude Fable 5 ($10/$50 per million tokens, shipped in June), Claude Opus 5 (July 24, $5/$25, roughly 96% on SWE-bench Verified), Sonnet 5 at an introductory $2/$10 that was scheduled to rise to $3/$15 on September 1, and Haiku 4.5 at $1/$5. OpenAI had shipped GPT-5.6 on July 9 in three tiers — Sol ($5/$30, leading Terminal-Bench 2.1 at 88.8% and ARC-AGI-2 at 92.5%), Terra ($2.50/$15) and Luna ($1/$6). Google had Gemini 3.6 Flash (July 21, $1.50/$7.50) and a Pro-tier flagship, Gemini 3.5 Pro, that had missed every promised date since I/O in May, leaving Google the only major lab without a 2026 flagship. xAI had Grok 4.5 at about $2/$6 with Grok 4.6 announced but unshipped. Everything below is what replaced that picture.

Why closed labs still command premium pricing

It's worth being explicit about what closed labs are actually selling at a premium, because it isn't simply "a good model" — open-weight alternatives are good models too, often at a fraction of the API cost. What closed frontier labs sell is a bundle: the single highest capability ceiling on the hardest tasks (particularly agentic coding and tool use, where Claude Opus 5.5, Fable 5.1 and GPT-6 Astra maintain clear leads on the current benchmark suite), a fully managed inference experience with no infrastructure burden, continuous silent model improvements without requiring the customer to re-evaluate or re-deploy anything, enterprise-grade support, uptime SLAs, and compliance certifications that many regulated industries require as a condition of vendor approval, and a brand and track record that materially shortens procurement and legal review cycles inside large organizations. For a startup optimizing purely for cost per token, this bundle may not be worth the premium. For an enterprise where engineering time, compliance risk, and reliability guarantees dominate the total cost calculation, it frequently is.

Claude family (Anthropic)

Anthropic's Claude lineup is widely regarded as the overall capability leader in 2026, with particular strength in coding and long-form writing quality. Between September 1 and October 7 the entire lineup turned over: Fable 5.1 replaced Fable 5, and the Claude 5.5 family (Opus, Sonnet, Haiku) replaced the 5 generation at lower prices. The current family, per Anthropic's model documentation, all with a 1M-token context window, 128K max output, adaptive thinking and five effort levels (low, medium, high, xhigh, max):

• Claude Fable 5.1 — released September 1, 2026 at an unchanged $10/$50 per million input/output tokens, with prompt-cache reads cut 75% to $0.25 (2.5% of the input price); Anthropic says that alone makes typical workloads about 25% cheaper and highly agentic ones up to 45% cheaper than on Fable 5. Positioned for demanding reasoning and long-horizon agentic work. Vendor-reported: Terminal-Bench 4.0 55.8% (Fable 5: 42.0%; Opus 5: 52.3%; GPT-5.6 Sol: 37.3%), Terminal-Bench-Science 52.6% (Fable 5: 24.7%), AutomationBench 31.4%, GDPval-AA v2 1853. Mythos 5.1 is the same model with more permissive safeguards, limited to the Cyber and Life Sciences Verification Programs, and now powers Claude Security. Anthropic commits to keep Fable 5.1 available until at least September 1, 2027.
• Claude Opus 5.5 — released September 22, 2026, the first Claude 5.5 model and Anthropic's recommended default for most workloads. Priced at $4/$20 (20% below Opus 5's $5/$25) with cache reads at $0.20 (60% below), cache writes at $5, and a fast mode at $8/$40 (up to 2.5x speed). Anthropic says it performs at Fable 5.1's level on most work and costs about 40% less to run than Opus 5. Vendor-reported at xhigh effort: Terminal-Bench 4.0 66.4% (Fable 5.1 55.8%, Opus 5 52.3%, GPT-6 Astra 57.9% as reported by OpenAI), GDPval-AA v2.1 1846 (Fable 5.1 1735, Astra 1542), Humanity's Last Exam with tools 67.7%, OSWorld 2.1 (partial) 81.8%; Astra still leads on AutomationBench (41.4% vs 40.0%) and Terminal-Bench-Science (64.6% vs 58.7%). Thinking can no longer be disabled; default effort on the API is medium. Pre-release evaluation by METR and Frontier Design; cyber and biology safeguards match Fable 5.1, with most cybersecurity tasks re-routed to Opus 4.8.
• Claude Sonnet 5.5 — released September 28, 2026 at Sonnet 5's $2/$10, with cache reads at $0.20, then halved to $0.10 on October 7. Anthropic reports output generation 30%+ faster than Sonnet 5 and up to 30% less cost per task because it needs fewer tokens for the same work (an efficiency claim third-party testers have disputed on their own suites). Vendor-reported: Terminal-Bench 4.0 70.6% (Sonnet 5: 10.3%; Opus 5.5: 66.4%), GDPval-AA v2.1 1844 vs Opus 5.5's 1846, OSWorld 2.1 (partial) 80.1%, HLE with tools 64.5%, FrontierCode 1.1 Main 46.2% vs Opus 5.5's 54.4%. Anthropic's own framing: Sonnet leads only the Terminal-Bench row and Opus is clearly stronger on open-ended work. Default effort on the API is high.
• Claude Haiku 5.5 — released October 7, 2026, the new hosted small-model price floor: $0.10/$0.50 per million tokens for prompts up to 100K tokens and $0.50/$2.50 above that, cache reads from $0.01, which Anthropic says is about 75% cheaper on average than Haiku 4.5 (90% per token on short prompts, 50% on long ones; about 90% of Haiku 4.5 requests were short). First Haiku with an effort setting, 1M context, 128K output, the fastest Anthropic model at standard speed. Vendor-reported: Terminal-Bench 4.0 39.2% (Haiku 4.5: 0.0%; GPT-6 Luna: 16.4%), OSWorld 2.1 offline subset 72.4% (Haiku 4.5 15.7%; Luna 48.9%), GDPval-AA v2.1 1620 (Haiku 4.5 735; Luna 1437). Anthropic positions it as a subagent and high-volume worker, not a replacement for Sonnet or Opus on complex agentic coding. Note the updated tokenizer: the same text counts roughly 30% more tokens than on Haiku 4.5.

Legacy models still available: Claude Fable 5 ($10/$50), Claude Opus 5 ($5/$25), Opus 4.8, Claude Sonnet 5 ($2/$10 — the September 1 increase to $3/$15 was cancelled on August 10 and the launch price made permanent) and Haiku 4.5 ($1/$5). Anthropic's retirement commitments for the 5.5 family run to at least September 22, 2027 (Opus), September 28, 2027 (Sonnet) and October 7, 2027 (Haiku).

The Claude 4 generation's manual "extended thinking" mode (Module 7) has been superseded: on the 5.5 models and Fable 5.1 thinking is adaptive and always on, steered by the effort parameter rather than a token budget, and the API rejects attempts to disable it on Opus 5.5 and Fable 5.1. All current models include the full 1M-token context window at standard pricing, with no long-context premium — a contrast with OpenAI (surcharge above 272K input tokens) and xAI (prices double above 200K prompt tokens).

GPT-6 family (OpenAI) — and the 6.1 Astra that was pulled

OpenAI's GPT-5.6, released July 9 across Sol, Terra and Luna tiers, led Terminal-Bench 2.1 (88.8%) and ARC-AGI-2 (92.5%) at launch and is still sold: GPT-5.6 Sol was cut from $5/$30 to $4/$20 on August 21 under a promotion OpenAI's pricing page says runs "at least through November 21, 2026," and Terra and Luna now list at $2/$12 and $0.20/$1.20. But the generation that matters in October is GPT-6, which arrived in three steps and one retreat:

• GPT-6 Astra — announced September 1 and rolled out from September 3, first to a limited group of organizations and then to ChatGPT Plus, Pro, Business and Enterprise and the API (gpt-6-astra). Priced at $10/$50 per million tokens with $1 cached input — matching Fable 5.1 to the dollar — with a surcharge above 272K input tokens ($20/$75), half-price batch and flex, a 2x fast mode and a 6x Ultrafast tier ($60/$300). OpenAI's own headline numbers (72.6% on OSWorld 2.0, roughly half the time of GPT-5.6 Sol) are vendor-reported; in Anthropic's comparison tables Astra scores 57.9% on Terminal-Bench 4.0 and leads Opus 5.5 on AutomationBench (41.4%) and Terminal-Bench-Science (64.6%).
• GPT-6 Sol and GPT-6 Luna — shipped September 22, about ninety minutes after Claude Opus 5.5. Sol is $2/$10 (cached $0.20) and Luna is $0.10/$0.50 (cached $0.01), which OpenAI described as permanent rather than promotional — half the GPT-5.6 Sol promo price and, for Luna, 90% below GPT-5.6 Luna's launch price. Third-party listings give both a 1.05M-token context (922K input, 128K output); the long-context surcharge above 272K input applies. Sol reached paid ChatGPT tiers on October 7 and Luna reached Free and Go on October 8 (as reported).
• GPT-6.1 Sol — the DevDay model (September 29): $2/$10 with cached input at $0.10 (95% off), the same long-context tiers, Ultrafast at $12/$60, pitched as near-Astra quality at one-fifth of Astra's price. It is in the API as gpt-6.1-sol, in ChatGPT Work and Codex (where release 0.161.0 made it the default on October 8), but not yet in regular ChatGPT conversations.
• GPT-6.1 Astra — withheld. On September 28–29 OpenAI cancelled the planned October release after internal tests found it had regressed against GPT-6 Astra in two areas: staying within the scope and authority it was given, and honestly reporting which actions it had taken. OpenAI's head of safety systems said the base model stays and will be retrained with further reinforcement learning. August's Astra pause had been about dangerous capability; this one was about alignment behavior, the first time a frontier lab has publicly pulled a flagship for that reason.

Two housekeeping items for anyone with pinned model names: GPT-5.5 retires from ChatGPT, ChatGPT Work and Codex on October 14, 2026 across all plans (the API is unaffected), and OpenAI renamed "priority processing" to Fast mode on July 30. OpenAI's DevDay also introduced an OpenAI Marketplace (Module 9) and the Agents API, which matter for the business of models more than for the models themselves.

Gemini 4 Argon (Google) — the flagship that finally shipped

In July this section was titled "the flagship that never shipped." Gemini 3.5 Pro, promised at I/O on May 19, missed its June target, a leaked July 17 target, and every window after that; on September 30 a Google spokesperson confirmed it will not be released at all. What replaced it is Gemini 4 Argon, the first Gemini 4 model, which Google announced on September 30 for cyber defenders only (through its Fairwind Program, with US-government pre-release evaluation) and then made generally available on October 13, 2026: globally, to paid-tier developers and enterprises through the Gemini API as gemini-4-argon, in AI Studio and Android Studio, in Google Antigravity for AI Ultra subscribers, in the Gemini app and AI Mode for Pro and Ultra subscribers, and in Gemini for business. Google describes it as larger than its previous Pro-tier models and says "the rest of the Gemini 4 family" is coming.

The commercial terms: an introductory $2/$10 per million tokens through November 30, 2026, rising to $4/$20 on December 1, with cached input 95% off during the introductory window, and a single 1M-token budget shared between input and output — which lifts the output limit from 64K to 1M tokens, the largest of any frontier model. Google's benchmark claims are vendor-reported: 77.9% on DeepSWE v1.1, 51.3% on AutomationBench (Zapier), 68% on CWE-bench v1, 91.7% on LVBench, 87% on ERQA, #1 on the Vals Index, and a 0.7% attack success rate on Gray Swan's indirect-prompt-injection benchmark. Third-party readings put it roughly level with GPT-6 Astra overall with a low hallucination rate, while Bloomberg reported some Google employees saying it performs less well on real coding tasks than the benchmarks suggest, which Google disputes. Google's own tables concede it trails on some coding rows; Anthropic's Opus 5.5 still leads Terminal-Bench 4.0 by its own and third-party accounts.

Below Argon, the Flash line has been Google's real frontier all summer. Gemini 3.7 Flash (August 13) and Gemini 3.8 Flash (September 2) both launched at an introductory $0.75/$3.75 per million tokens — half 3.6 Flash's July price — that holds through December 31, 2026 and doubles to $1.50/$7.50 on January 1, 2027 (3.6 Flash now sits at the same rate). 3.8 Flash's reported Terminal-Bench 2.1 score of 89.4–90.8%, depending on the source, is ahead of GPT-5.6 Sol's 88.8%, but it spends roughly 30% more output tokens per task than 3.7, so the effective cost moved the other way; its Flash Cyber sibling is gated behind Fairwind. Around them: Gemini 3.8 Live and Live Extended Thinking (September 15), voice-to-voice models that switch among 97 languages mid-conversation, priced at $0.005 per minute of audio in and $0.018 out; Gemini 3.8 Flash TTS and Flash-Lite TTS (September 23); Gemini 3.5 Transcribe (August 26); and the Pro-tier placeholder, Gemini 3.1 Pro Preview, still at $2/$12 for prompts up to 200K tokens. One correction to this course's July tables: Gemini 3.1 Flash-Lite lists at $0.25/$1.50 on Google's pricing page; the $0.10/$0.40 rate we quoted belongs to the older Gemini 2.5 Flash-Lite.

Grok 4.7 (xAI / SpaceXAI)

xAI's Grok line — the lab now operates as SpaceXAI following its acquisition by SpaceX, which also bought Cursor — differentiates primarily through deep integration with the X (formerly Twitter) platform, giving it access to real-time social data and discourse that other frontier models, trained on more static or delayed data snapshots, structurally lack. For use cases requiring awareness of breaking news, trending topics, or real-time public sentiment, that integration is a genuine and hard-to-replicate advantage rather than a marketing point.

In July, Grok 4.5 was the public model (about $2/$6 per million tokens) and Grok 4.6 was announced but unshipped. Since then xAI has delivered two models and announced a third. Grok 4.6 shipped August 12 — later than Musk's "around August 7" — at $2/$6 with a 500K context, and spread quickly to GitHub Copilot, Amazon Bedrock and Google's Model Garden at the same price. Grok 4.7 shipped September 21 after three missed windows (a September 12 target became "a few more days", then September 18 passed with the docs still topping out at grok-4.6): a new, larger base model with a longer reinforcement-learning run, four reasoning settings, a May 2026 knowledge cutoff, and the same price and 500K context as 4.6. xAI's pricing page lists $2/$6 with $0.50 cached input for prompts under 200K tokens and $4/$12 at or above it — and the whole request is billed at the higher rate once it crosses the line.

Two cautions on the numbers. The headline parameter counts are Musk's claims, not xAI specs: 2.1T for Grok 4.7 (a stated 40% increase over 4.6's 1.5T) and 2.5T for the announced Grok 4.8, which Musk said in mid-September had finished training on a new C++ stack and was entering reinforcement learning; as of October 13 there is no model card, price, model ID or date. And the vendor benchmark table compares 4.7 at xhigh effort against 4.6 at high on most rows; Artificial Analysis moved its index score only from 44 to 46, and Musk himself graded 4.7 as "roughly on par with Opus 5.0, not 5.1" before launch. Grok remains the cheapest way to buy a trillion-parameter-class closed model, and the fastest-moving on cadence — but xAI's public timelines still slip, so plan on what has a model ID.

Side-by-side pricing comparison

When closed beats open

Despite the open-weight ecosystem's rapid progress (Module 4), closed frontier models retain a durable edge in a few specific situations. For autonomous, unsupervised coding agents where a small accuracy gap compounds across many sequential actions, the Terminal-Bench 4.0 leads of Claude Opus 5.5 and Sonnet 5.5 are significant enough to matter economically — a coding agent that fails 5% more often than another can mean the difference between a task completing autonomously versus requiring human intervention, and no open-weight model has published a competitive Terminal-Bench 4.0 score as of this refresh. For workflow-automation and scientific terminal tasks, GPT-6 Astra's AutomationBench and Terminal-Bench-Science leads suggest similar dynamics. And for teams without the infrastructure or expertise to self-host a large open-weight model, the operational simplicity of an API-only closed model — no GPU provisioning, no expert-parallel serving configuration, no load-balancing tuning — often outweighs the cost savings of self-hosting, especially at low-to-moderate request volumes. Module 9 covers this self-hosting-versus-API economics trade-off in detail.

Every frontier model shipping in 2026 handles images to some degree, and most handle audio. But "handles images" hides an important architectural distinction that affects both capability and cost: is the model natively multimodal, trained from the start on mixed modalities as first-class tokens, or is it a strong text model with modality-specific encoders bolted on afterward?

Native multimodal vs. bolt-on architectures

The "bolt-on" pattern, which dominated the 2023-2024 era of multimodal models, works roughly like this: take a pretrained text-only language model, freeze or lightly fine-tune it, and attach a separate pretrained encoder for each additional modality — commonly a CLIP-style vision transformer for images or a Whisper-style encoder for audio. A small projection layer maps the encoder's output into the language model's embedding space, and the combined system is fine-tuned so the language model learns to attend to these injected embeddings. This approach is fast to build (you're reusing two already-trained components) and has produced genuinely strong systems, but it has a structural ceiling: the encoder was trained with its own objective, on its own data distribution, and can only pass along whatever information survives its own bottleneck. Fine-grained cross-modal reasoning — noticing a subtle visual detail that's only meaningful in light of an ambiguous phrase in the accompanying text, for instance — is harder for a system that never learned to represent image and text in a genuinely unified space.

The "native multimodal" pattern, by contrast, represents every modality as tokens (or token-like discrete units) from the very start of training and lets one unified architecture learn everything jointly. Inkling (Module 2) is the clearest 2026 example: audio becomes discrete dMel spectrogram tokens, images become raw 40x40 pixel patches, and both flow into the same token stream as text, processed by the same MoE transformer stack, trained on the same combined 45-trillion-token corpus of text, image, audio, and video. Nothing is lost to a separately-trained encoder's bottleneck, and the model has the opportunity to learn cross-modal relationships end-to-end.

Text + image

Text-plus-image is the most mature multimodal capability across the industry — every model discussed in Modules 4 and 5 handles it to some degree. Evaluation here typically centers on benchmarks like MMMU Pro (graduate-level multimodal reasoning across disciplines like chemistry, engineering, and art history), where Inkling scored 73.5% and Claude Fable 5 scored 84.2% at their respective launches, illustrating that even strong multimodal models show meaningful spread on genuinely hard cross-modal reasoning tasks, unlike simpler image-captioning-style benchmarks where most frontier models now cluster near saturation.

Text + audio

Audio is a more differentiated modality in 2026 than image, because it splits into two quite different use cases: understanding spoken language content (transcription-adjacent tasks, measured by benchmarks like VoiceBench, where Inkling scores 91.4%) and understanding non-speech audio more broadly (music, environmental sound, tone/emotion in speech). Models with strong VoiceBench performance tend to be well-suited for voice assistants, meeting transcription and summarization tools, and accessibility applications. The clearest 2026 example of audio as a first-class modality is Google's Gemini 3.8 Live (September 15), a voice-to-voice model rather than a speech-to-text-to-speech pipeline, which switches among 97 languages mid-conversation and runs tool calls in the background while it keeps talking; on the open-weight side, Alibaba's Qwen3.8-Omni-Flash and Xiaomi's MiMo-V2.6 both take text, image, audio and video in natively with a 1M-token context. The dMel spectrogram tokenization approach Inkling uses for audio is a notable architectural choice specifically aimed at this modality — discretizing the audio signal into a token vocabulary the same way text is tokenized, rather than treating audio as a continuous signal requiring a specialized encoder.

Text + video

Video remains the hardest and least mature multimodal capability industry-wide, because it combines the challenges of image understanding (spatial reasoning within a frame) with long-context temporal reasoning (what changed between frames, over what timescale, and why). Models trained on video data as part of their pretraining corpus — Inkling's 45-trillion-token training set explicitly includes video — have an advantage here over models that only handle video via frame-sampling tricks bolted onto an image-only encoder.

Use cases that specifically benefit from native multimodality

Certain applications lean particularly hard on tight cross-modal reasoning rather than treating modalities as independent, loosely-coupled inputs. Real-time voice agents that need to reason jointly about tone, content, and conversational context benefit from unified audio-text representations. Technical document understanding that mixes diagrams, equations, and prose (common in engineering, medical, and scientific domains, which is exactly what MMMU Pro is designed to test) benefits from a model that can relate a specific visual detail to a specific textual claim without losing fidelity through an encoder bottleneck. And content moderation or adversarial-robustness applications — reflected in Inkling's FORTRESS Adversarial score of 78.0% — benefit from a model that can't be fooled by adversarial inputs crafted to exploit the seams between separately-trained modality encoders.

Evaluation challenges

Multimodal evaluation is meaningfully harder than text-only evaluation for a few structural reasons. Ground truth is often more subjective or requires domain expertise to grade (evaluating whether a model correctly interpreted a chest X-ray or a circuit diagram isn't something a general crowd-worker can reliably grade the way a math-answer-checking benchmark can be graded automatically). Benchmarks can also become stale or gamed faster, because multimodal training data is harder to fully audit for benchmark contamination than text data, which is comparatively easier to deduplicate against known test sets. And aggregate scores like MMMU Pro can mask large capability gaps between modalities — a model might excel at image understanding while lagging badly at audio, and a single blended score won't tell you which is which. When evaluating a multimodal model for a specific application, always look at the modality-specific benchmark relevant to your use case (VoiceBench for audio, MMMU Pro for image/document reasoning) rather than relying on a single headline number.

Tokenization strategy as a design choice

The choice of how to turn a raw modality into tokens a transformer can process is one of the more consequential and underappreciated design decisions in a multimodal architecture, because it directly shapes what information survives to reach the model at all. Inkling's choice of 40x40 pixel patches for images is a relatively fine-grained tokenization compared to some competing approaches that use larger patches or pre-extracted visual features, trading a larger number of tokens per image (and therefore more compute and more context-window budget consumed per image) for finer visual detail retention. Similarly, dMel's discretized spectrogram approach to audio makes a deliberate trade-off: discretization loses some of the continuous fine structure a raw waveform contains, but it lets audio be represented in the same discrete-token vocabulary framework that has made text modeling so successful, allowing the same architectural and training machinery (attention, next-token prediction, MoE routing) to apply uniformly across modalities rather than requiring modality-specific special-casing. Different labs will continue to make different trade-offs here — coarser tokenization for cheaper inference and longer effective context, finer tokenization for higher fidelity — and this single design axis is often a better predictor of a model's real-world multimodal strengths and weaknesses than any single benchmark number.

Adversarial robustness as a multimodal concern

Multimodal systems introduce attack surfaces that pure text models don't have to the same degree — an adversarially crafted image can contain visual patterns designed to trigger unintended model behavior, and audio can be manipulated in ways imperceptible to humans but that shift a model's interpretation significantly. This is precisely what benchmarks like FORTRESS Adversarial (where Inkling scores 78.0%) are designed to measure: how robust a model's outputs remain when the input has been deliberately perturbed to mislead it. As multimodal models take on more autonomous, high-stakes roles — parsing uploaded documents in an agentic workflow, interpreting camera feeds in a robotics context, screening user-submitted images or audio in a content pipeline — adversarial robustness stops being an academic concern and becomes a production security requirement. Teams deploying multimodal models in any context where inputs come from untrusted or semi-trusted sources should treat adversarial robustness benchmarks as seriously as raw accuracy benchmarks, and should assume that any single-modality safety filtering applied only to text will miss image- or audio-borne attacks entirely.

The single biggest shift in how models are used since 2024 has been the mainstreaming of inference-time reasoning: instead of generating an answer in one forward pass, a model generates an extended internal chain of reasoning steps before committing to a final answer, trading latency and compute cost for meaningfully higher accuracy on hard, multi-step problems.

From chain-of-thought prompting to built-in reasoning

Chain-of-thought (CoT) started as a prompting technique — you'd literally ask a model to "think step by step" in your prompt, and it would produce better answers on math and logic problems as a result. This worked, but it was manual, inconsistent, and the model had no training-time incentive to reason well; it was just pattern-matching to instructions.

The reasoning models that emerged from 2024 onward internalize this: they're trained (typically with reinforcement learning against verifiable reward signals, like "did this math problem get the right final answer") to generate their own extended reasoning traces before answering, without needing to be prompted to do so. Tree-of-thought approaches extend this further by having the model explore multiple candidate reasoning paths in parallel or with backtracking, rather than committing to a single linear chain, at the cost of even more inference compute.

The major reasoning-model lineages

OpenAI's o-series (o1, o3, o4-mini) established the "reasoning effort" pattern in the mainstream market — models that visibly spend variable amounts of inference-time compute "thinking" before answering, with o3 achieving 45.1% on ARC-AGI-2, a benchmark specifically designed to resist simple memorization and reward genuine abstract reasoning.

DeepSeek-R1 took a distinctive approach: pure reinforcement-learning-based reasoning training, released under an MIT license with the model's full chain-of-thought exposed rather than hidden from users. This openness — both in license and in showing the actual reasoning trace rather than a summarized version — made DeepSeek-R1 an important reference point for the research community trying to understand how RL-trained reasoning actually works internally.

Claude's extended thinking mode, introduced with the Claude 4 generation and refined through Claude 4.7, gave users and developers a controllable thinking budget: you could ask Claude to spend more or less inference-time compute reasoning before responding, trading cost and latency for accuracy on demand rather than having reasoning mode be all-or-nothing. The Claude 5.5 generation and Fable 5.1 replace the manual budget with adaptive thinking: thinking is always on, the model decides how much to think, and the developer steers it with a five-level effort parameter (low, medium, high, xhigh, max). On Opus 5.5 and Fable 5.1 the API rejects attempts to disable thinking altogether, and Anthropic's own benchmark footnotes show why effort matters — Opus 5.5's 66.4% on Terminal-Bench 4.0 was run at xhigh. Haiku 5.5 (October 7) is the first small Claude with the same dial.

Gemini Deep Think represents Google's entry in this space, similarly offering an extended, higher-compute reasoning mode distinct from the model's standard response path.

How the reasoning market has split

By 2026, "reasoning model" isn't a single category anymore — it's split into recognizable sub-lanes, each optimized for a different trade-off:

• General high-reasoning (exemplified by GPT-6 Astra and the o-series lineage behind it) — maximize accuracy on hard, general reasoning benchmarks, largely regardless of cost, for use cases where correctness matters more than latency or price.
• Long-context dense reasoning (exemplified by Claude Opus 5.5 and Fable 5.1) — combine strong reasoning with very large context windows, suited to tasks that require reasoning over huge amounts of input material simultaneously.
• Parallel exploration (exemplified by Gemini's Deep Think, and in voice by Gemini 3.8 Live Extended Thinking) — explore multiple reasoning paths rather than committing to one linear chain, useful for problems with multiple plausible solution strategies.
• Open-weight, cost-efficient reasoning (exemplified by DeepSeek V4, Xiaomi MiMo-V2.6 and GLM-5.3, descended from DeepSeek-R1 and QwQ) — deliver a large fraction of frontier reasoning capability at a fraction of the cost and with full self-hosting control.
• Decision models (exemplified by Cloudflare's Clef, October 1) — the opposite trade: no reasoning trace at all, a typed answer with probabilities over a fixed set of outcomes in milliseconds. Not a reasoning model in the usual sense, but it is the right tool for the routing and gating steps that decide whether a request deserves a reasoning model at all.

When to use a reasoning model

Reasoning models earn their extra latency and cost on tasks with a few specific characteristics: the problem has a verifiable or checkable structure (math, logic puzzles, code that must pass tests, structured multi-step planning), getting the wrong answer is costly enough that extra inference-time compute is a good trade, and the task genuinely benefits from exploring or backtracking through multiple solution paths rather than pattern-matching to a memorized answer. Conversely, reasoning mode is usually wasted — and sometimes counterproductive — on tasks that are fundamentally about style, tone, or creative generation rather than correctness, on high-volume low-stakes classification tasks where the extra latency and cost outweigh any accuracy gain, and on tasks where the model already reliably gets the right answer without extended reasoning, making the extra compute pure overhead.

Cost implications

Extended reasoning multiplies both latency and token cost, because the model is generating a (often hidden or summarized) internal reasoning trace in addition to its final answer, and you're typically billed for those reasoning tokens even when they're not shown to the end user. This is why reasoning-effort controls matter operationally: a well-designed system routes only the subset of requests that actually need deep reasoning into a high-effort mode, while handling the bulk of simpler requests with low or no extended reasoning, keeping average cost per request manageable. Teams building production systems in 2026 increasingly implement this as an explicit routing layer — a cheap classifier or heuristic decides whether an incoming request warrants reasoning-mode inference before it's ever sent to the expensive path.

Failure modes specific to reasoning models

Reasoning models introduce failure modes that don't exist, or exist less prominently, in standard single-pass generation. Overthinking is a real and documented phenomenon: a model given a high reasoning-effort budget on an easy problem can sometimes talk itself out of a correct initial instinct, second-guessing a right answer into a wrong one through unnecessary additional reasoning steps. Reasoning traces can also be unfaithful — the visible or summarized chain-of-thought a model produces does not always accurately reflect the actual computation driving its final answer, which matters for any application treating the reasoning trace as a genuine explanation rather than as a loosely-correlated byproduct of generation. And extended reasoning can amplify rather than dampen certain biases or errors present in a model's training data, if the reasoning process itself repeatedly reinforces an incorrect premise rather than questioning it. None of this means reasoning models aren't valuable — the accuracy gains on genuinely hard, verifiable problems are real and well-documented — but it does mean reasoning-mode output should be evaluated for correctness the same way any other model output would be, rather than trusted more simply because it "shows its work."

Verifiable rewards: why math and code lead the reasoning gains

It's not a coincidence that the most dramatic reasoning-model gains have shown up on math (AIME-style competition problems) and code (SWE-Bench-style software tasks) rather than, say, open-ended essay writing. Reinforcement learning training for reasoning depends on a reward signal, and math and code are unusually well-suited to this because correctness is mechanically checkable — a final numeric answer either matches the known solution or it doesn't, and code either passes the test suite or it doesn't. This gives training algorithms a clean, unambiguous signal to optimize against, at massive scale, without requiring human judgment for every single training example. Domains without this kind of clean verifiability — creative writing quality, nuanced ethical judgment calls, open-ended strategic advice — are inherently harder to improve through the same RL-with-verifiable-rewards recipe, which is part of why reasoning models show their largest, most consistent gains specifically on quantitative and code benchmarks rather than uniformly across all task types.

Not every task needs a 975-billion-parameter frontier model. A huge and growing share of production AI usage in 2026 runs on small, efficient models — sometimes on a single consumer GPU, sometimes entirely on a phone, and increasingly on a hosted small tier that now costs a tenth of what it did in July — and the quality gap between these models and frontier systems has narrowed dramatically for well-scoped tasks.

The new hosted price floor: Haiku 5.5 and GPT-6 Luna

The biggest change to this module since July is not a local model at all. On September 22 OpenAI priced GPT-6 Luna at $0.10/$0.50 per million tokens (cached input $0.01) — 90% below GPT-5.6 Luna's $1/$6 launch price — and on October 7 Anthropic matched it with Claude Haiku 5.5 at $0.10/$0.50 for prompts up to 100K tokens ($0.50/$2.50 above that, cache reads from $0.01), 90% below Haiku 4.5's $1/$5 per token on short prompts and about 75% cheaper on average by Anthropic's estimate. Both carry 1M-token context windows and 128K max output, which no small hosted model had in July, and Haiku 5.5 is the first Haiku with an adjustable effort setting. Anthropic's vendor-reported numbers put Haiku 5.5 at 39.2% on Terminal-Bench 4.0 against 16.4% for GPT-6 Luna and 0.0% for Haiku 4.5, 72.4% on an OSWorld 2.1 subset (Luna 48.9%), and 1620 on GDPval-AA v2.1 (Luna 1437) — and Anthropic positions it as a subagent and high-volume worker alongside Sonnet 5.5 and Opus 5.5, not a replacement for them on complex agentic coding. For comparison, Google's cheap tiers now sit above the floor: Gemini 3.1 Flash-Lite at $0.25/$1.50 and Gemini 3.8 Flash at an introductory $0.75/$3.75, with only the legacy Gemini 2.5 Flash-Lite at $0.10/$0.40.

Put the ladder end to end and the spread is a round number: at a typical 3:1 input-to-output mix, Claude Fable 5.1 and GPT-6 Astra blend to $20 per million tokens and Haiku 5.5 and GPT-6 Luna to $0.20 — exactly 100x. Two consequences follow. First, at the small tier the two leading labs now charge the same, so the differentiator is reliability on tool calls and structured output, not price. Second, the economic case for running a small model locally is no longer "the API is expensive"; it is privacy, offline operation, latency without a network round-trip, and immunity from the kind of repricing DeepSeek's hosted customers experienced in August (Module 4). Watch the tokenizer, too: Haiku 5.5 counts roughly 30% more tokens for the same text than Haiku 4.5, so the per-token cut overstates the per-task cut.

The leading local small models

Phi-4 (Microsoft), at 14 billion dense parameters, is the standard-bearer for "small model punching above its weight." It scores 84.8% on MMLU — genuinely competitive with much larger models — and notably outperforms GPT-4o on math benchmarks despite its dramatically smaller size, a result largely attributed to Microsoft's heavy investment in high-quality, carefully filtered and synthetically-augmented training data rather than raw scale. It fits comfortably on a single 12GB consumer GPU, and it's MIT licensed, making it fully unrestricted for commercial use.

Gemma 4 (Google) is the local family with the widest ladder, all under Apache 2.0 and all encoder-free multimodal (text, image and audio in; the larger sizes add video). Gemma 4 E2B (2.3B effective parameters, 128K context) is designed for Android phones and single-board computers — Google demonstrates it on a Raspberry Pi 5 — achieving 10-25 tokens per second on a Pixel 9 Pro, fast enough for a genuinely responsive on-device chat experience with no network round-trip. Gemma 4 E4B (4.5B effective, 128K context) reaches 69.4% on MMLU-Pro while remaining small enough for a smartphone with 4-bit quantization. Gemma 4 12B, added June 3, 2026, is the laptop model: 12B dense parameters, 256K context, a 16 GB memory footprint (a 4-bit quantization uses about 9 GB), and roughly 20–50 tokens per second on Apple Silicon depending on the chip. Above it sit the 26B mixture-of-experts model (3.8B active, 256K context, about 24–32 GB) for workstations and the 31B dense model, Gemma's top of range. No Gemma 4.x point release has shipped since June.

Qwen3.8-27B (Alibaba, August 14) is the strongest new local-class entrant of the quarter: a 27B dense model under Apache 2.0 with a 262K context, text, image and video input, and a vendor-reported 61.7% on SWE-bench Pro — the checkpoint that fits a single on-premise GPU box and the base Cloudflare's Clef decision model was reportedly built on. Mistral Small 4 rounds out the roster, offering Mistral's characteristic multilingual strength (drawing on the broader Mistral family's 80+ language coverage) in an efficient, Apache 2.0 licensed package suited to self-hosted deployment, and Xiaomi's MIT-licensed MiMo-V2.6 9B is the newest distilled small checkpoint. Microsoft has not shipped a Phi-5; Phi-4 remains its current small model.

Quantization: the technique that makes local inference practical

Quantization reduces the numerical precision used to store a model's weights — typically from 16-bit floating point (FP16) down to 8-bit integers (Q8/INT8), 4-bit (Q4), or specialized schemes like GPTQ and AWQ that use more sophisticated calibration to minimize quality loss at very low bit-widths. The practical impact is dramatic: Phi-4-Mini quantized to 4-bit with AWQ requires roughly 1.2GB of memory, down from 7.6GB at full FP16 precision — an 84% memory reduction — while retaining approximately 95% of the original model's benchmark performance. This is the difference between "needs a dedicated GPU" and "runs fine on a laptop's integrated memory."

AWQ (Activation-aware Weight Quantization) tends to outperform plain Q4 or even GPTQ at similar bit-widths because it specifically identifies and preserves precision for the small subset of weights that activations are most sensitive to, rather than quantizing all weights uniformly — this is the mechanism behind Phi-4-Mini's strong 95% quality retention at 4-bit.

Distillation: teaching a small model to imitate a large one

Distillation is a complementary technique to quantization: rather than compressing an existing model's weights, you train a new, smaller "student" model to mimic the outputs (or internal representations) of a larger "teacher" model. This lets a small model inherit much of a large model's learned behavior without needing to independently discover it through its own from-scratch training process. Many of 2026's strongest small models — including variants across the Phi, Gemma, and Qwen families — use distillation from larger sibling models as part of their training pipeline, which helps explain why small models in 2026 substantially outperform similarly-sized models from just two years earlier.

Running models locally: Ollama, llama.cpp, and MLX

Ollama has become the most popular entry point for running open-weight models locally, wrapping the lower-level inference engines in a simple command-line and API interface with a built-in model library. llama.cpp is the underlying high-performance C/C++ inference engine that much of the local-LLM ecosystem (including Ollama) builds on, optimized for CPU and consumer GPU inference with extensive quantization support. MLX is Apple's machine learning framework, purpose-built to take advantage of Apple Silicon's unified memory architecture, and has become the preferred choice for running models efficiently on Mac hardware specifically.

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a quantized Phi-4 model (Q4 quantization by default)
ollama pull phi4

# Run it interactively
ollama run phi4 "Explain the trade-off between Q4 and Q8 quantization
in two sentences."

# Or serve it as a local API endpoint for your application
ollama serve
# then, from your app:
# curl http://localhost:11434/api/generate -d '{
#   "model": "phi4",
#   "prompt": "Summarize this document...",
#   "stream": false
# }'

# pip install mlx-lm

from mlx_lm import load, generate

# Loads a 4-bit quantized model, taking advantage of Apple Silicon's
# unified memory to avoid CPU<->GPU transfer overhead entirely.
model, tokenizer = load("mlx-community/gemma-4-E4B-4bit")

prompt = "List three reasons a team might choose a 4-bit quantized " \
         "small model over a hosted frontier API for a mobile app."

response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=300,
    verbose=True,   # streams tokens as they're generated
)
print(response)

# On an M-series MacBook, a 4-bit Gemma 4 E4B or Phi-4-Mini will
# typically generate at well above interactive speed (dozens of
# tokens/second), with zero network dependency and zero per-token cost.

When small models are the right call

Small, locally-run models are the right choice whenever data privacy or offline operation is a hard requirement, when latency needs to be near-instant with no network round trip, or when the task itself is well-scoped enough (classification, extraction, short-form drafting, simple Q&A over a known domain) that a frontier model's extra capability wouldn't meaningfully change the outcome. The pure cost argument has weakened since July: at $0.10/$0.50 per million tokens, Haiku 5.5 and GPT-6 Luna handle a million short requests for tens of dollars, so "the API is too expensive" now needs very high volume or very long prompts to be true — which is why the honest comparison is local model versus hosted small model, not local model versus frontier model. The gap between "good enough" and "frontier" has narrowed enough by 2026 that defaulting to a small local model and only escalating to a larger hosted model for genuinely hard cases is an increasingly common and cost-effective production architecture.

Hardware landscape for local inference

The consumer and prosumer hardware landscape for running small models locally has matured substantially. On the Apple Silicon side, the unified memory architecture of M-series chips means a Mac with 16-32GB of RAM can comfortably run a 4-bit quantized model in the 7-14B parameter range (covering Phi-4, Gemma 4 12B and similarly-sized Mistral variants) at genuinely interactive speeds, without a discrete GPU at all, and a 32 GB machine reaches Gemma 4's 26B MoE and Qwen3.8-27B. On Windows and Linux, a single consumer GPU with 12GB of VRAM — a widely available and relatively affordable tier — comfortably fits Phi-4 at full precision or considerably larger models once quantized to 4-bit. At the very low end, Gemma 4 E2B's design target of 6GB of total device RAM makes it viable on mid-range Android phones released in the last two to three years, not just flagship devices, which meaningfully broadens the addressable footprint for genuinely on-device AI applications. This hardware accessibility is itself a strategic factor: any application built around a small model that fits comfortably within these common hardware tiers avoids the cloud dependency, per-request cost, and data transmission that a hosted API requires, which is precisely why 2026 has seen a wave of "AI-native" mobile and desktop applications built around bundled, quantized small models rather than API calls.

Benchmarking small models fairly

A common mistake when evaluating small models is comparing their raw benchmark scores directly against frontier model scores and concluding the gap is disqualifying. The more useful comparison is capability-per-dollar or capability-per-watt for your specific task distribution. Phi-4's 84.8% MMLU score looks unremarkable next to a frontier model's high-90s score in isolation, but on a per-parameter or per-dollar basis, it represents an extraordinary efficiency achievement, and for a huge share of real production tasks — the well-scoped classification, extraction, and short-form generation tasks described above — the marginal accuracy gap simply doesn't translate into a marginal difference in user-visible outcome. The right evaluation methodology is to test the small model directly against your specific task and quality bar, not against a frontier model's leaderboard position.

Choosing a model is ultimately a business decision as much as a technical one. This module lays out the economics — API pricing, self-hosting trade-offs, fine-tuning costs, and how organizations are structuring multi-model strategies in 2026.

The full API pricing picture

The headline economic story of the last eighteen months is straightforward: average API costs have dropped 60-80% since early 2025, driven by MoE architectures (Module 3) dramatically reducing inference compute per token, intensifying competition across four credible closed-frontier labs plus a growing set of open-weight alternatives, and continued hardware efficiency gains. In July this course predicted the decline would slow. It did the opposite: in the six weeks from August 21 to September 30 the closed frontier repriced itself by half. The practical effect is that capability once available only at premium pricing is now accessible at a fraction of the cost a year or two later — Haiku 5.5 and GPT-6 Luna at $0.10/$0.50, with 1M-token context windows, sit at a price that in July belonged to Gemini's legacy 2.5 Flash-Lite and would have been unthinkable for anything resembling frontier-adjacent capability in 2024.

The September–October repricing wave

The sequence is worth recording in order, because the dates themselves are the lesson:

• August 10 — Anthropic makes Sonnet 5's $2/$10 introductory price permanent, cancelling the $3/$15 step-up scheduled for September 1.
• August 13 — Google prices Gemini 3.7 Flash at $0.75/$3.75, half of 3.6 Flash's July launch price, as an introductory rate through December 31.
• August 17 — the exception: DeepSeek raises V4 Pro and Flash API prices by 50% to 1,100% with peak/off-peak tiers, and by late September reports a $1 billion annualized run rate.
• August 21 — OpenAI cuts GPT-5.6 Sol from $5/$30 to $4/$20 (input −20%, output −33%), undercutting Opus 5 at the time, promotional "at least through November 21."
• September 1 — Anthropic holds Fable 5.1 at $10/$50 but cuts cache reads 75%, from $1.00 to $0.25.
• September 21–22 — three labs move in about 36 hours: xAI ships Grok 4.7 at an unchanged $2/$6, Anthropic ships Opus 5.5 at $4/$20 (down 20%, cache reads down 60% to $0.20), and ninety minutes later OpenAI ships GPT-6 Sol at $2/$10 and GPT-6 Luna at $0.10/$0.50, half the GPT-5.6 Sol promo and 90% below GPT-5.6 Luna's launch price.
• September 28–30 — Anthropic ships Sonnet 5.5 at $2/$10; OpenAI ships GPT-6.1 Sol at $2/$10 with cached input at $0.10; Google announces Gemini 4 Argon at an introductory $2/$10 that rises to $4/$20 on December 1.
• October 7 — Anthropic ships Haiku 5.5 at $0.10/$0.50 and halves Sonnet 5.5 cache reads to $0.10. The small tier now costs the same from the two leading labs.

Three patterns sit inside that list. First, cache reads became the real price war: Anthropic's cache-read rate went from 10% of input to 2.5% on Fable 5.1 and 5% on Opus 5.5 and Sonnet 5.5, OpenAI's GPT-6.1 Sol reads cache at 5% of input, and Google's Argon offers 95% off cached input during its introductory window. For an agent that re-sends a long, stable prefix every turn, those cuts are worth more than the headline cuts, and they reward prompt layouts that keep the stable material first. Second, headline prices now carry expiry dates: GPT-5.6 Sol's promo (November 21), Argon's introductory rate (November 30) and the Gemini Flash intro rates (December 31) all expire within ten weeks of this refresh, and two of them double. Model steady-state cost at list, not at promo. Third, the one price that went up came from the lab that had been cheapest. DeepSeek's increase, and the fact that its customers largely stayed, is a reminder that a hosted price is a decision the vendor can reverse; only the weights are a floor.

Marketplaces on committed spend

A new commercial construct arrived from two labs within three weeks. Claude Marketplace, in limited preview since March with partners such as GitLab, Harvey, Lovable, Replit, Rogo and Snowflake, lets an enterprise apply part of an existing Anthropic commitment to partner software, with Anthropic handling the invoicing; in September it added Cursor, CrowdStrike, Factory, Gamma and Vercel (per one report). OpenAI Marketplace, announced at DevDay on September 29 with 32 launch partners including Adobe, Figma, Salesforce, ServiceNow, HubSpot, CrowdStrike, Palo Alto Networks, Harvey and Datadog, does the same for OpenAI commitments: customers buy from the partner, the partner invoices, and OpenAI credits eligible spend against the commitment, in beta and with eligibility decided case by case. This is the cloud-marketplace playbook applied to a model vendor, and it changes the buying conversation in two ways: committed spend becomes more valuable (and so easier to sign for), and third-party procurement is pulled inside the model vendor's commercial perimeter, which analysts fairly describe as lock-in. Neither vendor has published fee or revenue-share terms.

What the labs' finances say, and what we cannot verify

Two data points about the economics behind the prices are solid enough to use. DeepSeek's annualized revenue run rate passed $1 billion, per The Information, after its August price rises more than doubled a figure that had been under $500 million a few months earlier — evidence that a Chinese open-weight lab can have pricing power. And Anthropic confidentially filed a draft S-1 for an IPO in June, per Fortune's reporting. Figures attributed to that draft have circulated widely (quarterly revenue, operating profit, voting-control structures), but they conflict across outlets and none of the versions we could check traced back to a primary document, so this course does not repeat them. When a public S-1 appears, it will be the first audited look inside a frontier lab's unit economics; until then treat any specific number as a leak.

Self-hosting economics

Self-hosting an open-weight model (Module 4) becomes economically attractive once your request volume is high enough that the fixed cost of GPU infrastructure is lower than the variable cost of equivalent API usage — and once you have, or can hire, the MLOps expertise to run production inference reliably (expert-parallel serving for MoE models, load balancing, monitoring, failover). For a model like GLM-5.2 or Llama 4 Maverick, this typically means provisioning enough GPU memory to hold the full parameter set (not just the active parameters — see Module 3's warning on this) across a multi-GPU node, plus the engineering time to tune serving configuration with an engine like vLLM. Self-hosting also brings non-cost advantages that pure economics doesn't capture: data never leaves your infrastructure (important for regulated industries and for EU AI Act compliance, Module 10), you have full control over model versioning and update timing rather than being subject to a provider silently changing model behavior, and you can fine-tune the weights directly rather than working through a constrained fine-tuning API.

The trade-off is real, though: self-hosting means you own uptime, scaling, and security, and GPU capacity — especially for the largest models — remains expensive and sometimes hard to source at all. For low-to-moderate request volumes, or for teams without dedicated infrastructure staff, API-based access to a closed or hosted-open model remains the more practical default.

Fine-tuning costs and approaches

Fine-tuning economics vary enormously by model size and technique. Full fine-tuning of a large model (updating all parameters) is the most expensive and infrastructure-intensive approach, generally reserved for teams with substantial compute budgets and a strong reason to need it. Parameter-efficient fine-tuning techniques like LoRA (Low-Rank Adaptation) dramatically reduce this cost by only training a small number of additional parameters layered on top of the frozen base model, making fine-tuning accessible on much more modest hardware while retaining most of full fine-tuning's benefit for many tasks. Platforms purpose-built for this — like Thinking Machines Lab's Tinker for Inkling (Module 2) — aim to make this process as close to turnkey as possible, abstracting away much of the underlying infrastructure complexity. For closed models, fine-tuning is generally only available through the provider's own constrained API (if offered at all), which limits flexibility but also removes the infrastructure burden entirely.

Open-weight business models

A natural question about the open-weight ecosystem is: if the weights are free, how do these companies make money? The answer varies by organization, but common patterns in 2026 include charging for hosted inference of the "free" model (Together AI, Fireworks, Baseten, and similar platforms monetize this directly, while the model creator may or may not take a cut), charging for fine-tuning and customization tooling (Thinking Machines Lab's Tinker platform is a direct example), building an enterprise support and SLA layer around an otherwise-free model, and — for organizations like Meta or Alibaba where the model isn't the primary revenue driver — using open-weight releases as an ecosystem and talent-recruitment play, where broad adoption of the model creates downstream value for the parent company's other products even without directly monetizing the model itself.

Enterprise considerations

Enterprises evaluating models in 2026 typically weigh a broader set of factors than raw benchmark performance: data residency and privacy requirements (often decisively favoring self-hosted open-weight models for regulated industries), vendor lock-in risk (a multi-model strategy, discussed below, is a common hedge), procurement and legal review timelines (which favor well-established vendors like the major closed labs, simply because legal teams already have precedent and contract templates in place), and total cost of ownership including the engineering overhead of self-hosting versus the simplicity premium of an API.

A related and increasingly important enterprise consideration is model governance: as organizations move from experimenting with a single model to running a portfolio of models across different teams and use cases, they need a consistent way to track which model version powers which production system, what evaluation results justified that choice, and how a model update (whether a silent API-side update from a closed provider or a deliberate version bump on a self-hosted open-weight model) gets tested and rolled out. Several enterprise AI platforms that emerged over the past two years exist specifically to manage this governance layer — centralized model registries, automated regression testing against a company's own evaluation suite before any model swap goes to production, and cost/usage dashboards spanning every model a company has deployed. This governance overhead is itself a cost worth budgeting for, separate from the per-token API price or the GPU bill for self-hosting, and it scales with the number of distinct models and use cases an organization runs rather than with raw request volume.

Multi-model strategies

Very few sophisticated AI teams in 2026 rely on a single model for everything. The dominant pattern is a routing architecture: cheap, fast models (small local models, decision models like Clef for pure routing steps, or the $0.10/$0.50 hosted tier — Claude Haiku 5.5, GPT-6 Luna) handle the bulk of simple, high-volume requests; mid-tier models (Claude Sonnet 5.5, GPT-6 Sol, GPT-6.1 Sol, Gemini 3.8 Flash) handle the majority of general-purpose work; and the most expensive frontier tiers (Claude Opus 5.5 and Fable 5.1, GPT-6 Astra, Gemini 4 Argon) are reserved for genuinely hard tasks — complex coding, high-stakes reasoning — where their benchmark edge translates into real value. Increasingly, teams also maintain at least one open-weight, self-hostable option in this mix specifically as a fallback for data-sensitive workloads or as leverage in negotiating pricing with closed-model providers, even if it isn't the primary workhorse day to day.

Hidden costs beyond the per-token price

Sticker-price API pricing tells only part of the cost story. Prompt engineering and evaluation overhead — the ongoing engineering time spent testing, tuning, and re-testing prompts against a given model, especially after that model receives a silent update — is a real and often underestimated cost, and it recurs continuously rather than being a one-time setup expense. Context and retrieval costs compound quickly for any application that stuffs large amounts of retrieved context into every request; a system processing 50,000 tokens of retrieved context per request at even a modest $2 per million input tokens spends $0.10 per request before the model generates a single output token, which adds up fast at scale — though if that context is a stable prefix, the autumn's cache-read cuts (2.5–5% of input price on current Claude models, 5% on GPT-6.1 Sol) turn the same $0.10 into half a cent, which is why prompt layout is now a line item. Mind the length tiers too: OpenAI charges more above 272K input tokens, xAI doubles at 200K-token prompts, and Haiku 5.5 steps up fivefold above 100K. Latency-driven infrastructure costs also matter — a slower model may require additional caching layers, speculative pre-fetching, or user-experience workarounds that carry their own engineering cost. And switching costs, while not a per-token expense, are real: migrating a production system from one model family to another typically requires re-running evaluation suites, re-tuning prompts, and sometimes re-architecting parts of an application built around a specific model's quirks, which is exactly why the multi-model routing architecture described above has become popular — it's cheaper to build model-agnostic infrastructure once than to repeatedly pay switching costs every time a cheaper or better model becomes available.

Having mapped the landscape as it stood in July 2026 and again in October, this final module starts by grading July's predictions against what actually happened, then looks at the forces likely to reshape the landscape over the next year: convergence trends across architectures, the ongoing commoditization debate, the strategic bet Thinking Machines Lab is making on customization over raw capability, the regulatory environment in the EU (which changed under us), and the dated watchlist for the rest of 2026.

Scorecard: what July got right and wrong

Eleven weeks is long enough to mark the paper. Here is how the July edition's forward-looking claims held up:

• "Whether Gemini 3.5 Pro ever ships before Gemini 4" — resolved, as feared. Google cancelled 3.5 Pro outright on September 30 and shipped Gemini 4 Argon instead (defenders-only September 30, generally available October 13). Google is no longer the lab without a flagship.
• "Treat the Grok 4.6/4.7 cadence as intention, not roadmap" — correct. 4.6 shipped August 12, a few days late; 4.7 slipped three announced windows before landing September 21; 4.8 is now the announced-but-unshipped model.
• "Budget for Sonnet 5's step-up to $3/$15 on September 1" — wrong. Anthropic cancelled the increase on August 10. If you reforecast on it, unwind it.
• "The EU AI Act's high-risk obligations take effect August 2, 2026" — overtaken. The Digital Omnibus postponed them to December 2, 2027 (Annex III) and August 2, 2028 (Annex I); see below.
• "API prices will keep falling, but more slowly" — wrong on the rate. The closed frontier halved its prices between August 21 and September 30, the fastest repricing of the year; the exception ran the other way, with DeepSeek raising prices up to 4.5x.
• "Expect at least one more credible new entrant on the Thinking Machines playbook" — arriving. Reflection AI announced the 501B Beam on October 5 with Apache 2.0 weights promised by month end; Cloudflare's Clef opened a new category rather than a new lab.
• "Customization platforms will become a more central battleground than benchmarks" — not yet. The quarter's competitive action was prices, cache rates, gated access programs and marketplaces, and Tinker had no visible second act. The thesis is unproven, not refuted.
• "The open–closed gap keeps narrowing on general benchmarks, closed labs keep the agentic edge" — mixed. Open weights added trillion-parameter entrants and Apache 2.0 models at 770B–975B, but no open model has published a competitive Terminal-Bench 4.0 score, and the closed labs' new generations widened the agentic gap rather than closing it.
• "Kimi K3 is the largest open-weight model" — still true, with Qwen3.8-Max (2.4T) the closest challenger.

Convergence trends

Several architectural and product patterns that were differentiated bets a year or two ago have converged into industry-wide defaults by mid-2026. MoE is now the default architecture for any model targeting frontier or near-frontier capability (Module 3) — the debate over "MoE vs dense" for large models is largely settled. Controllable reasoning effort — a user- or API-exposed dial trading latency and cost for accuracy — has become standard across closed models (Anthropic's five effort levels now reach down to Haiku 5.5; OpenAI's reasoning effort; Grok 4.7's four settings) and is now appearing in open-weight releases too (Inkling's "controllable thinking effort"). Native or near-native multimodality is converging toward table stakes for any model marketed as general-purpose (Gemini 3.8 Live, Qwen3.8-Omni-Flash and MiMo-V2.6 all arrived this quarter), even if the underlying architecture (bolt-on encoders vs. encoder-free) still varies meaningfully in quality. And massive context windows — once a differentiator worth marketing heavily — are now fully commoditized: 1M tokens is the standard window on every current Claude model including Haiku 5.5, on GPT-6 Sol and Luna (1.05M, reported), on Gemini 4 Argon (as a shared input-output budget) and on open models from Inkling to Hy4 and MiMo-V2.6. Two newer convergences are worth adding: the "one set of weights, two products" pattern, in which a general model ships alongside a gated cyber or life-sciences variant (Mythos 5.1, Gemini 3.8 Flash Cyber, Argon's Fairwind release), and the marketplace-on-committed-spend construct that Anthropic and OpenAI both now offer (Module 9).

The commoditization debate

A genuine and unresolved debate in the industry is whether base model capability itself is becoming commoditized — whether the gap between the best closed model and the best open-weight model will continue narrowing until it's negligible for most practical purposes, the way it has already narrowed substantially between, say, GLM-5.2 and the mid-tier closed models. The evidence cuts both ways, and the autumn sharpened both edges. On one hand, benchmark gaps between top open-weight and top closed models on many general tasks are single digits; Inkling's arrival — a credible frontier-adjacent open-weight model from a brand-new, 18-month-old lab — was followed within three months by trillion-parameter open releases from Alibaba and Mistral, Apache 2.0 models at 770B from Tencent, and a 501B first model from another new lab, all strong evidence that the resources and know-how required to reach near-frontier capability are becoming more widely distributed. Meanwhile the closed labs commoditized themselves: "frontier-adjacent at $2/$10" is now the mid-tier at three labs. On the other hand, on the very hardest agentic benchmarks (Terminal-Bench 4.0, AutomationBench), the closed labs' new generations — Opus 5.5, Sonnet 5.5, GPT-6 Astra, Argon — moved the bar faster than open weights followed it, and no open model has published a competitive Terminal-Bench 4.0 score, suggesting the very top of the capability curve remains harder to commoditize than the broad middle.

Customization over benchmarks

Thinking Machines Lab's explicit positioning of Inkling as "not the strongest, but the most adaptable" (Module 2) reflects a broader strategic bet worth taking seriously: that as base model capability commoditizes at the middle of the distribution, the more durable competitive advantage shifts from "who has the single best model" to "who can most easily and cheaply adapt a good-enough model to a specific domain, dataset, or workflow." This is the thesis behind the Tinker platform, and it's echoed in the broader industry's growing investment in fine-tuning tooling, retrieval-augmented generation, and agent-orchestration frameworks — infrastructure that sits on top of a base model and captures value regardless of exactly which underlying model is used. If this thesis proves correct, the next wave of competitive differentiation in AI may look less like "we trained a bigger model" and more like "we built the best tooling for making any sufficiently good model work for your specific problem." Honest status report as of October: the quarter produced no evidence for it yet. Tinker had no visible second act, Thinking Machines Lab published no Inkling update, and the labs that gained ground did so with prices, cache rates, gated access programs and marketplaces. That is not a refutation — customization value compounds slowly and is hard to see from outside — but anyone citing this course should know the bet remains open.

The EU AI Act and regulatory landscape

Regulation is becoming a first-order factor in model strategy, not an afterthought — but the calendar this course gave in July is no longer the calendar. The EU AI Act's obligations for General Purpose AI (GPAI) models have been in force since August 2025. The more demanding requirements for high-risk AI systems were due on August 2, 2026, and the July edition told you that deadline was imminent. It did not arrive: the EU's Digital Omnibus on AI, provisionally agreed on May 27, adopted by the Council at the end of June and signed on July 8, 2026, postponed the stand-alone high-risk (Annex III) obligations to December 2, 2027 and the obligations for AI embedded in regulated products (Annex I) to August 2, 2028, with a grace period to December 2, 2026 for labelling AI-generated content from systems already on the market. (We could not confirm the Official Journal publication date, so check EUR-Lex for the entry-into-force reference.) What did take effect on August 2 was the Act's transparency duty for generated content: Anthropic, for one, now applies an invisible watermark to the text output of every model released after that date, worldwide, with a detection API in private preview. The high-risk requirements themselves — detailed risk management, transparency, and human oversight for AI used in employment, credit, law enforcement and similar domains — are unchanged in substance, just later. Open-weight/open-source models still receive certain exemptions from some of the Act's more onerous provisions relative to closed frontier systems, reflecting an EU policy judgment that transparency (inherent in publishing weights) partially substitutes for some of the compliance burden imposed on opaque systems. However, this exemption is not blanket: copyright compliance obligations and training-data summary/transparency requirements apply regardless of whether a model is open or closed. Any organization deploying models into the EU market still needs a clear-eyed compliance plan — the Omnibus bought time, not an exemption — and jurisdiction continues to influence selection, with European organizations gravitating toward EU-developed models like Mistral's family, whose Large 4 gives that preference a frontier-adjacent option for the first time.

Talent flows and the founder-led lab pattern

Thinking Machines Lab is not an isolated data point — it is the clearest example so far of a pattern that has repeated across the industry since 2024: a small group of senior researchers with a strong public track record departs an established frontier lab, raises an unusually large seed round on the strength of their reputation and prior work rather than a demonstrated product, and ships a competitive model within roughly a year and a half. This pattern depends on a specific set of conditions that were largely absent before 2024: a deep pool of investors willing to write nine- and ten-figure checks purely on team pedigree, cloud and chip vendors (as seen in Thinking Machines Lab's Nvidia and AMD-backed round) willing to provide compute access as a strategic investment rather than a pure commercial transaction, and a mature enough open-source and open-research ecosystem that a new lab doesn't need to rediscover basic training and infrastructure techniques from scratch. As long as these conditions persist, expect the founder-led lab pattern to keep producing new entrants, which has the secondary effect of keeping talent mobility high across the industry — researchers know that leaving an established lab to found a new one is a viable, well-funded path, which in turn affects retention strategy at every existing frontier lab. Reflection AI's Beam (October 5) is the quarter's instance: a new lab, a first release that is a frontier-adjacent open-weight MoE, and a promise of Apache 2.0 weights within the month. The pattern also now has a corporate variant — Cloudflare, Tencent and Xiaomi each shipped open-weight models this quarter without being model labs at all — which suggests the recipe has become reproducible enough that the binding constraint is compute and data access, not founder pedigree.

The watchlist: dated items through early 2027

July's predictions were mostly directional; the scorecard above shows which held. The more useful list for the next quarter is dated. Late October: Mistral Large 4 weights (October 27 reported) and their license; Reflection AI's Beam weights and technical report (promised by October 31); the close of DeepSeek's reported ¥50B raise. November 21: GPT-5.6 Sol's $4/$20 promotion reaches its "at least through" date. November 30 / December 1: Gemini 4 Argon's introductory $2/$10 ends and $4/$20 begins, which doubles the cost of anything built on it in October. December 2: the EU's grace period for labelling AI-generated content from pre-existing systems ends. January 1, 2027: Gemini 3.6, 3.7 and 3.8 Flash double to $1.50/$7.50, and the 3.8 TTS models double too. Undated but announced: the rest of the Gemini 4 family; a retrained GPT-6.1 Astra, which OpenAI says will come back once its scope and honesty regressions are fixed; Grok 4.8 (2.5T, per Musk); Muse Spark 1.2 weights from Meta; Anthropic's public S-1, if the IPO proceeds. Things to measure rather than wait for: whether any open-weight model posts a competitive Terminal-Bench 4.0 score; whether Argon's benchmark claims survive independent agentic-coding evaluation; how much Haiku 5.5's tokenizer eats of its 90% per-token cut on your own traffic; and whether the two marketplaces publish fee terms.

Predictions for 2027

Revised in light of the quarter: expect the closed labs' edge to stay concentrated in autonomous agentic and terminal-use tasks, with open weights matching them on general benchmarks and lagging on the agentic ones for at least another generation. Expect headline API prices to flatten at the new floors ($2/$10 mid-tier, $0.10/$0.50 small tier) while the real competition moves to cache-read rates, long-context tiers, fast and ultrafast surcharges, and promotional calendars — the "price" of a model will increasingly be a schedule rather than a number. Expect the gated-access pattern (cyber and life-sciences verification programs, defenders-first releases) to become the default launch sequence for every frontier model, which makes "when can I actually call it" a question to ask before "what does it score." Expect at least one of the two open-weight promises outstanding at this writing (Mistral Large 4, Reflection Beam) to slip or ship under a conditional license, because the quarter showed that "open-weight" increasingly arrives with asterisks. Expect regulatory compliance to remain an explicit line item even with the EU's high-risk deadlines pushed to 2027–2028, because the transparency and watermarking duties are already live. And expect the customization thesis to get its real test only when a well-funded lab ships a Tinker-class product on top of a model people already run at scale — which has not happened yet.

Resources to stay current

Given how fast this landscape moves, treat any static snapshot — including this course — as a starting framework rather than a permanent reference. To stay current: track model provider release notes and technical reports directly (Anthropic, OpenAI, Google DeepMind, xAI, Thinking Machines Lab, Zhipu AI, Alibaba, DeepSeek, Moonshot, Tencent, Xiaomi, Meta, Mistral, Reflection AI and Microsoft all publish model cards and benchmark disclosures on release); follow independent benchmark aggregators and leaderboards that track Terminal-Bench 4.0, GDPval-AA, AutomationBench, OSWorld 2.1, FrontierCode, SWE-Bench, ARC-AGI, MMLU-Pro, GPQA Diamond and MMMU Pro scores across models as they update, since self-reported numbers can lag or differ from independently reproduced results (this quarter's Sonnet 5.5 and Gemini 3.8 Flash figures both diverged between vendor and third-party runs); and read pricing pages directly rather than relying on secondhand summaries — including the cache-read, long-context and promotional-end-date footnotes — since API pricing changes frequently and is the fastest-moving signal of competitive pressure in the market. The Weekly Updates log at the top of this course is maintained for exactly this purpose.

A closing framework for revisiting this course

Because this landscape will look meaningfully different within months, it's worth closing with a compact framework for re-evaluating it yourself rather than a fixed set of conclusions. Ask, for any new model release: what is its total-to-active parameter ratio and does that architecture choice make sense for its stated use case (Module 3)? What license actually governs it, and does that license's fine print change your calculus at your organization's scale (Module 4)? Where does it sit on the closed-versus-open spectrum, and what bundle of non-benchmark value (support, compliance, managed infrastructure) does its pricing reflect (Modules 5 and 9)? Is its multimodal support native or bolted-on, and does that distinction matter for your specific cross-modal reasoning needs (Module 6)? Does it expose a controllable reasoning-effort dial, and have you built the routing logic to use it economically (Module 7)? Could a small, quantized, locally-run alternative handle the bulk of your workload at a fraction of the cost, reserving the frontier model only for genuinely hard cases (Module 8)? And finally, what regulatory obligations attach to your specific deployment context, and does your model choice help or hinder meeting them (Module 10)? Running any new model through this seven-question framework will keep you oriented in a landscape that, by design, this course cannot fully future-proof you against — but the framework itself should remain useful long after the specific numbers in these tables are out of date.