The Cost Curve

On July 31, 2026, DeepSeek published a retrained checkpoint called V4 Flash 0731 and moved the V4 Flash API into public beta. It kept the preview's architecture, 284 billion total parameters, 13 billion active parameters, 1-million-token context window, and MIT license. The weights received continued post-training—additional training on curated data after the main pretraining run, targeting agent traces, reinforcement targets, and distilled examples from stronger models^[2]. That pass pushed the budget model above DeepSeek's V4 Pro Preview, its own flagship, on nine agent benchmarks. The boundary between cheap and expensive models moved.

This drawing follows that boundary across the full cost picture. It traces the token-dollar ledger from model architecture to the price of a completed task. It walks through quantization—the technique that shrinks a 167 GB checkpoint to laptop size by reducing the numerical precision of each weight. It explains what checkpoint retraining reveals about the real cost of training, why labs selling expensive tokens keep cutting prices, and where the pressure goes next.

The mechanics outlast any release. Price per token is a ledger entry. Price per task is the cost that matters. The cheapest row on a vendor's card keeps falling.

DeepSeek ships V4 in two sizes. Pro is the flagship: a 1.6-trillion-parameter model. Flash is the efficiency edition, with 284 billion total parameters. They frame a budget decision—Pro for the capability ceiling, Flash for the lower bill. The architectural trick that makes Flash cheap is its mixture-of-experts (MoE) layout: only 13 billion of those 284 billion parameters are active for any given token. The rest sit idle, waiting to be selected by a learned router. An MoE model carries many specialized sub-networks (experts) and activates a small subset per input, trading total capacity for per-token efficiency.

The 0731 release breaks that hierarchy. The checkpoint retains the preview's architecture, parameter count, and context window. Continued post-training from the preview checkpoint retuned the weights, avoiding a new pretraining run^[2]. Flash 0731 then beat V4 Pro Preview on practical agent benchmarks. DeepSeek moved the Flash API to public beta and positioned it for agent tasks—workloads where a model acts on tools, code, and multi-step instructions rather than answering single questions. The release adds Responses API support and specific adaptation for Codex, OpenAI's coding agent environment^[1].

The shape of the checkpoint is the reason the price works:

Parameters are the learned numerical weights that define a neural network—the model's knowledge, stored as numbers. More parameters means more capacity to store patterns, at the cost of more memory and compute per token. The context window is how many tokens the model can attend to at once; a token is roughly three-quarters of an English word on average. fp8 means each weight is stored as an 8-bit floating-point number, a compact format that balances size against precision. The MIT license is a permissive open-source license that allows any use, including commercial and modification, with no restrictions beyond attribution and liability disclaimer.

The MIT license permits self-hosting: running the model on your own hardware rather than paying a vendor per API call. The active-parameter count makes that affordable. Only 13 billion weights are read from memory per generated token, so the bandwidth cost per token stays small even with 284 billion parameters sitting on disk.

The economic signal: a vendor's cheaper tier caught its flagship on procurement benchmarks using post-training alone—data and objective, not more parameters or a new architecture. The arithmetic that follows traces how that signal propagates through the cost structure.

A listed price combines a cost ledger and margin. The ledger entries also determine whether a request succeeds: how much GPU memory the weights occupy (weight footprint), how much computation each prompt token requires, and how much memory the KV cache consumes as it grows with context length and concurrent requests.

The KV cache—short for key-value cache—is the mechanism that makes autoregressive generation efficient. When a model produces text one token at a time, each new token must attend to all previous tokens. Rather than recomputing every previous token's intermediate representations from scratch, the model stores them as key-value pairs in memory. Each new token reads the cache without recomputing history. The tradeoff: the cache grows linearly with context length and with the number of simultaneous requests. A provider serving long-context agents is selling fast memory alongside compute.

Generation splits into two phases with different hardware demands. Prefill reads the entire prompt in large parallel matrix multiplications and is compute-bound—limited by how fast the GPU can perform arithmetic. Decode produces one token at a time, reading the model weights from GPU memory for each step, and is memory-bandwidth-bound—limited by how fast data moves from memory to the processor. Model pricing reflects the cost of each phase on the vendor's hardware.

MoE introduces a key distinction in this ledger. Total parameters inflate the weight file stored on disk, but decode streams only the active set through memory. The active count therefore sets the per-token bandwidth cost^[3]. Flash's 13 billion active parameters let a provider charge $0.28 per million output tokens. Each generated token reads relatively few bytes, even though the full checkpoint holds 284 billion parameters across 167 GB.

EQ. 1.1 calculates how much memory the model weights require. EQ. 1.2 estimates how fast the model can generate tokens given a fixed memory bandwidth—the rate at which data can be read from GPU memory, measured in gigabytes per second. Two numbers set the floor for every hosted price and self-hosting decision: how many bits you store per weight, and how many weights you touch per token. Fused kernels (optimized GPU routines that combine multiple operations into one), continuous batching (grouping requests together as they arrive rather than in fixed-size batches), KV paging (managing the KV cache in pages like virtual memory), and speculative decoding (using a smaller draft model to predict several tokens ahead, then verifying them in parallel with the main model) change quality, concurrency, and utilization. The two equations remain the physics underneath. The Model Sheet and The Inference Engine cover the full mechanics; this drawing applies the ledger to price.

Consider a server with 1,200 GB/s of memory bandwidth running a 13B-active MoE at 4.5 bits per weight. It reads about 7.3 GB per token, yielding roughly 164 tokens per second of decode throughput for one sequence. With 32 concurrent requests, aggregate throughput exceeds 5,000 tokens per second. At $0.28 per million output tokens, that is roughly 9 cents of revenue per thousand output tokens. The machine costs between $3 and $8 per hour to operate, depending on utilization—power, cooling, amortized hardware, and networking. The active-parameter count keeps bandwidth costs low; batching amortizes fixed costs across sequences.

The KV cache amplifies the cost difference. At 1 million tokens of context with Flash's dimensions, the per-request KV cache approaches tens of gigabytes. A cache-hit—when a new request reuses previously computed context, such as a long system prompt that appears in every call—costs $0.003 per million tokens, roughly 98% below the base input price of $0.14^[5]. A cache-miss—when context must be computed fresh—pays the full input rate. The near-free cache-hit price makes long-context, high-repetition workloads nearly free. Sheet 5 covers that effect.

When a vendor's per-token price falls, self-hosting costs fall with it because an open-weight checkpoint can be quantized. Quantization reduces the numerical precision of each weight—from 16 bits down to 8, 6, 4, or fewer—plus a small per-block scaling overhead that tracks how to rescale the compressed values. The model file shrinks proportionally. Flash 0731's full fp8 weight file is roughly 167 GB. Its Hugging Face repository—a popular model-sharing platform—lists dozens of GGUF variants spanning the full-size install down to aggressively quantized tiers around 33 GB^[4].

GGUF is the file format used by llama.cpp, the most common engine for running language models on consumer hardware. The quantization ladder is the family of GGUF variants, each trading size for quality:

• Q8: roughly 8 bits per weight, near-lossless. The file is about half the size of fp16 with no measurable quality drop on most tasks.
• Q6 and Q5: slight quality loss, still near-lossless for most uses. Q5_K_M is a common default for machines with room to spare.
• Q4: the standard balance. A Q4 model is about one-quarter the size of fp16 and retains roughly 96% of the quality on most benchmarks. Most self-hosted deployments start here.
• Q3: visibly degraded. Noticeable quality loss on precise tasks, but the model still runs and can be useful for high-throughput, low-precision workloads.
• Q2: last resort. Significant degradation. Only used when the model must fit on hardware that cannot accommodate a larger quant.

The k-quant family (Q4_K_M, Q5_K_M, etc.) allocates bits unevenly across blocks of weights, giving more precision to the weights that matter more and less to the rest. This preserves more quality at a lower average bit rate than uniform quantization. Below 4 bits, an importance matrix (imatrix)—a precomputed map of which weights the model relies on most—protects the critical weights from the worst degradation. IQ3_M, the imatrix-protected Q3 variant, often holds more quality than a plain Q3 at a similar bit rate. GPU-focused formats like AWQ and GPTQ exist for high-throughput serving on dedicated accelerators. fp8, an 8-bit floating-point format, is used by serving stacks that run the full-size model on datacenter GPUs.

Speed follows the ledger. Decode is bandwidth-bound: slower memory means fewer tokens per second. Quantization reduces bytes per token and therefore time per token. MoE compounds the effect—only the active parameters are read per token, and quantization shrinks that already-small byte count further. On a unified-memory machine like an M-series Mac, where the CPU and GPU share the same pool of RAM, the reduction determines whether a model fits at all.

The interactive panel above shows the quantization ledger. Size uses exact arithmetic (params × bpw ÷ 8). Quality percentages are hand-set to show the established pattern—near-lossless through about Q4, then a cliff—rather than measured scores. Speed is the bandwidth-bound multiplier versus FP16, the 16-bit floating-point reference format. The imatrix rung (IQ3_M) preserves more quality than a plain quant at a similar bit rate by protecting the weights the model relies on.

The Fit and Speed calculator shows how MoE architecture changes the self-hosting decision. Adjust total and active parameters independently. A 106B-parameter MoE with 12B active at Q5 needs about 73 GB for weights—tight on a 96 GB Mac and comfortable on 128 GB. A 70B dense model (where every parameter is active for every token) at Q4 needs about 39 GB, so it fits on more machines but generates fewer tokens per second per unit of bandwidth because every token reads all 70B parameters. The active-parameter count reduces both the vendor's GPU bandwidth bill and the time per token on your laptop.

Two independent sources measure the retrain's gains. Artificial Analysis, an independent model evaluation service that benchmarks models across standardized tasks using controlled infrastructure, runs every model through the same evaluations so results are comparable. Their Intelligence Index v4.1 is a composite of nine evaluations covering agentic work, scientific reasoning, coding, and long-context tasks. Flash 0731 scores 50 on this index—ten points above the April preview and third among all tracked models, behind Claude Opus 5 (61) and Kimi K3 (57)^[5][6].

A separate evaluation, GDPval-AA v2, measures performance on agentic real-world tasks—giving a model tools, instructions, and a goal, then scoring how effectively it completes the job. Scores use the Elo rating system, the same relative-ranking method used in chess: a higher Elo means the model wins more head-to-head comparisons against other models. Flash 0731's Elo rose from 1189 to 1559, a 370-point jump against a human baseline of 1000^[6].

Artificial Analysis reports improvement on every evaluation in the index:

DeepSeek's API changelog also reports nine agent benchmarks where Flash 0731 ranks above V4 Pro Preview^[1]:

The lab that retrained the model and sells access also produced the nine-benchmark headline. These are real benchmarks, but the evidence and the pitch share an author. Artificial Analysis independently confirms the direction, reporting approximately 79 on Terminal-Bench 2.1 versus DeepSeek's 82.7. The GDPval-AA v2 Elo jump is also third-party. The ordering carries more signal than the exact numbers, which drift between evaluations.

Evaluation cost connects these scores to the arithmetic in Sheet 5. Flash 0731 is a heavy reasoner—a model that generates many intermediate reasoning tokens before producing a final answer. On the Intelligence Index, it generated about 206 million output tokens, 12% fewer than the original's 234 million but more than double the median model's output^[5]. Heavy reasoners spend tokens to win. The verbosity—the ratio of reasoning tokens to final answer tokens—acts as a hidden multiplier on the output price. A model can look cheap per token and expensive per completed task.

Reliability adds context. The AA-Omniscience Index measures both accuracy (how often the model is correct) and hallucination rate (how often it generates incorrect information). Flash 0731 improved from -23 to -16 on the combined index, while accuracy held at 37% and the hallucination rate fell to 84%^[6]. The model improved by refusing to answer more often rather than by answering more questions correctly. Refusal is better than confabulation—generating plausible-sounding but false content—but it is a different kind of improvement than an accuracy gain. GPT-5.6 Terra has an 85% hallucination rate at comparable accuracy^[6]. These figures represent the state of the art for general-purpose language models.

DeepSeek lists Flash 0731 at $0.14 per million input tokens and $0.28 per million output tokens^[5]. Cache-hit input—when the prompt or a prefix of it was already computed and stored—costs $0.003 per million, roughly 98% below the base input price and the lowest rate across all models Artificial Analysis tracks^[5]. The industry-standard cache discount is about 90%. DeepSeek's near-total write-off on cached tokens is a structural pricing choice, not a temporary promotion.

V4 Pro costs $0.27 per million input tokens and $0.87 per million output tokens. On cache-miss traffic, where context must be computed fresh, DeepSeek priced V4 at roughly one-sixth the cost of Claude Opus 4.7 and one-seventh the cost of GPT-5.5. Artificial Analysis calculates that Flash 0731 costs roughly 60% less per finished task than the max-effort frontier model on the same index, even after OpenAI cut GPT-5.6 Luna's price by up to 80%^[6].

On paper, the model is cheaper by an order of magnitude. Three factors qualify that comparison. First, verbosity: a heavy reasoner using 1.6× as many output tokens to think before answering erodes the per-token discount—you pay for the reasoning tokens too. Second, cache dependence: the near-free cache-hit price applies only when requests share prefixes, such as long system prompts that appear in every call, repeated tool definitions, or agent loops with stable context. Without cache hits, the full input price applies. Third, input-output mix: workloads that stream long answers pay the output rate; workloads that read massive contexts pay the input rate. One model rarely minimizes both.

EQ. 3.1 calculates the full cost of a task. Cache-rate is the fraction of input tokens that hit the cache (0 to 1). Verbosity is the multiplier on output tokens the model spends on reasoning before the final answer. The equation separates the per-token ledger from the per-task cost. A model with a low per-token price and high verbosity can cost more per task than a model with a higher per-token price and low verbosity.

The Token Bill panel instantiates the equation. It is an illustration, not a benchmark: the prices and verbosity multipliers are named presets, not measured values. It demonstrates non-transitivity: the cheapest model on one workload is rarely cheapest on another, and the per-token price leader often loses on per-task cost.

Drag the sliders to see the ranking reorder. Set input tokens to 160,000 and the cache-hit price dominates: DeepSeek's $0.003 per million makes it cheapest by far, because most of the cost is cached input. Set output tokens to 30,000 and the output price plus verbosity multiplier reverses the ranking: the model with the lowest product of output price and verbosity wins, even with a higher input price. The task determines the cheapest model.

Running Flash 0731 through all nine evaluations in the Artificial Analysis Intelligence Index at max effort cost $72.02^[5]. For less than a nice dinner, a third-party evaluator tested a state-of-the-art reasoning model across agentic, scientific, and coding benchmarks. The same run on a frontier model at list prices would cost hundreds of dollars. That gap makes task-specific evaluation practical: you can afford to test a model on your own workload rather than accepting claims from a vendor's benchmark slide.

The day before Flash 0731 shipped, OpenAI cut GPT-5.6 Luna's price by up to 80%^[6]. DeepSeek had intensified the price competition months earlier by making a 75% cut to V4 Pro permanent, then partially reversing it with peak-hour surge pricing—charging higher rates during periods of maximum demand, similar to ride-share pricing. Chinese labs keep up the pressure. MiniMax Mimo 2.5 and ByteDance's latest model shipped within hours of each other, with MiniMax pricing input at $0.25 per million and output at $1.00—already above Flash's $0.14/$0.28. The whole field is racing capability up and price down simultaneously.

The cost structures explain the pricing gap. A lab that pretrains a frontier model from scratch must recover a large bill through token sales. Pretraining—the initial, expensive training run on massive text corpora that teaches the model language, facts, and reasoning patterns—is the largest single cost in producing a language model. Estimates for the largest runs range from $100 million to more than $1 billion in compute alone. Retraining an existing checkpoint costs far less: a post-training pass over high-value data may run in the low millions or below because the architecture and most of the learned structure are already paid for. The checkpoint can price near its recovery cost and still fund another iteration. When cheap open weights match a flagship's scores, analyst and investor concerns about open-source models pressuring proprietary labs' growth premiums follow directly from the cost structure^[6].

This pressure shifts where vendors capture value. As capability gets cheaper, the fee-for-capability portion of revenue shrinks. Surrounding services retain value: distribution infrastructure that routes requests to available GPUs, prompt caching at scale that stores repeated context, reliability and uptime that enterprise customers require, workflow integration that connects models to existing tools, proprietary data that customers use for fine-tuning (additional training on domain-specific data to customize a model's behavior), and eval pipelines that verify a model meets task-specific quality thresholds. Product quality can hold while revenue migrates to adjacent layers, as it has in every commoditizing part of the tech stack: operating systems, databases, cloud compute.

0731 is a retrained checkpoint—a saved snapshot of model weights after training. The preview's structure and size carried over unchanged while continued post-training retuned the weights^[2]. A focused pass over high-value data—agent traces (recordings of agents performing tasks), reinforcement targets (desired outputs used to train models via trial and error), and distilled examples (outputs from stronger models used to train weaker ones)—raised the Intelligence Index score by ten points without changing the architecture. Continued post-training costs far less than training from scratch because the architecture design, most learned representations, and the large pretraining compute bill are already paid for.

That cost structure has four effects:

First, the cost base becomes fixed capital. Labs can iterate frequently on data, objective, and training recipe without rebuilding weights from scratch. Flash 0731 is the second public checkpoint in roughly three months. At that cadence, a cheap checkpoint can close the capability gap faster than a frontier lab can complete another pretraining run.

Second, cheap iteration shifts the capability race toward post-training and distillation pipelines. Distillation is the technique of training a smaller "student" model on outputs from a larger "teacher" model, transferring capability into a cheaper architecture. DeepSeek's result implies that post-training choices—the data mix, reward signal, and distillation target—matter at least as much as pretraining scale while costing orders of magnitude less.

Third, distillation moves frontier capability into smaller active-MoE checkpoints. The beat-Pro result collapses the hierarchy behind the price ladder. If a retrained 13B-active checkpoint can match a 1.6T model on agent benchmarks, buyers who keep the larger model as their default are paying a premium for capability that is available cheaper.

Fourth, cheap checkpoint refinement lets a vendor cut prices aggressively. The $0.003-per-million cache-hit rate and $0.28-per-million output rate are sustainable because producing the checkpoint costs little relative to the revenue from any positive serving margin^[5].

This mechanism drives the near-term pressure. Labs compete to convert the best data and objectives into capability that smaller models can carry and serve at low marginal cost. Cheap tiers will keep closing the gap. Cache and serving costs will keep falling. Flagship premiums will keep shrinking. The expensive frontier stays because it owns the hardest, sparsest, most valuable problems. Most workloads, however, will move toward cheaper defaults.

The same pressure reaches the labs at the top of the price ladder, whose business model depends on selling the best model at a premium. They can build better models, but the mechanism funding each successor is breaking.

The capital flywheel. A frontier lab raises billions and commits a large share to its next pretraining run. OpenAI has raised roughly $300 billion in total funding and counting; Anthropic, more than $18 billion; Google DeepMind operates as a cost center inside a trillion-dollar parent; xAI is building a 200,000-GPU cluster. The run requires $100 million to $1 billion in compute, months of wall-clock time, and a research organization spending tens of millions per year on salaries. The resulting model sets a new state of the art. The lab charges $15 to $75 per million output tokens and uses API revenue to amortize the training cost.

Within weeks or months, an open-weight model closes most of the capability gap at roughly 1/50th the training cost by retraining an existing checkpoint—or, as frontier labs allege, by distilling the frontier model's outputs: sending millions of queries to the expensive API, collecting the responses, and training a smaller model on those input-output pairs. The open-weight model charges $0.28 per million output tokens. To preserve volume, the frontier lab cuts prices by 50%, then 80%. Revenue flattens before the training run is paid off. The next funding round must cover both another pretraining run and the unamortized cost of the last one.

Each iteration compresses the cycle. The gap between "best model ships" and "open-weight model closes the gap" was measured in years in 2023 and months in 2025. Flash 0731 gained ten Intelligence Index points with the same architecture and price roughly three months after the April preview. The premium pricing window can now close before the lab finishes paying for the premium model.

The distillation allegation as a structural feature. Frontier labs often respond to open-weight catch-up with the same accusation: the competitor distilled their model without permission. They claim the open-weight lab generated millions of outputs from the frontier API, trained on those input-output pairs, and transferred the capability into a cheaper architecture at a fraction of the cost.

Outside observers generally cannot verify whether a specific checkpoint used distillation because labs do not disclose their full training data—the set of examples used to train the model. The open-weight lab can claim independent data collection; the frontier lab can cite suspicious benchmark correlation. Only the training lab knows the truth, and the accusation remains useful without proof in a particular case.

The allegation creates a rationale for regulatory intervention. Framing open-weight models as "distilled without permission" instead of "independently developed" recasts export controls on model weights, API access restrictions, and mandatory watermarking (embedding detectable patterns in model outputs to trace their origin) as intellectual property enforcement rather than commercial protectionism. It converts "we cannot compete on price" into "they should not be allowed to compete." Its role will grow as the price gap widens.

The allegation also supports an investor narrative. A frontier lab raising another multi-billion-dollar round must explain why the previous one failed to produce a durable competitive moat. "Our IP was stolen" is more fundable than "the cost curve moved under us."

Where the pressure forces them. Frontier labs have the best models, deepest research teams, largest compute clusters, and enterprise and regulatory relationships unavailable to open-weight labs operating from China. They will use those advantages in several ways:

First, vertical integration into the application layer. Shrinking API margins push value higher in the stack—the layers of software built on top of models. ChatGPT, Claude, and Gemini already serve as their labs' primary consumer distribution channels. Revenue from $20-per-month subscriptions is stickier and carries higher margins than per-token API billing. Frontier labs will expand into vertical SaaS: coding agents, legal research, medical transcription, financial analysis. The model becomes the cost of goods sold for a software business rather than the product itself.

Second, enterprise moats. A Fortune 500 procurement department switches models less readily than a developer switches API endpoints. Enterprise contracts include SLAs—service level agreements that guarantee uptime and performance—indemnification against legal liability, compliance certifications for regulated industries, data residency guarantees that keep data within specified jurisdictions, dedicated capacity that reserves GPU time, fine-tuning and RLHF (Reinforcement Learning from Human Feedback, a training method that aligns models with human preferences) on proprietary data, and integration with existing identity and security infrastructure. An MIT-licensed model in a Hugging Face repository offers none of these. Frontier labs will focus on enterprise sales because procurement creates durable switching costs measured in millions of dollars instead of cents per token.

Third, regulatory moats. Frontier labs are American companies operating under American law; their Chinese competitors operate under a different legal and regulatory regime. Export controls on advanced chips already limit who can train frontier models, and policymakers are debating controls on model weights. Safety arguments hold that capable models require careful deployment, open-weight releases enable misuse, and adversarial access to frontier capability creates a national security risk. Those arguments can be both sincerely held and strategically useful. Requirements for safety evaluations, pre-deployment review, and liability for downstream harm raise shipping costs and favor labs with existing compliance infrastructure.

Fourth, owning the infrastructure layer beneath open-weight models. Open-weight models need compute to run. Vendors can sell the GPUs even when they cannot control weight downloads. Every major cloud provider offers model catalogs that deploy open-weight models on its infrastructure with a few clicks. Google, Microsoft/OpenAI, and Amazon/Anthropic can capture revenue from open-weight usage regardless of which model tops a benchmark because the tokens still run on their silicon.

Fifth, pushing the frontier outward faster than followers can close in. Catch-up models target last quarter's frontier. Claude Opus 5 scores 61 on the Intelligence Index, 11 points above Flash 0731 at 50. Each cheap checkpoint narrows that headroom. A frontier lab can preserve premium pricing only by widening the gap faster than cheaper models close it. Doing so requires more pretraining investment and a race against depreciation on every run.

Read the trap diagram from left to right. Each frontier pretraining run creates a capability gap—the vertical bracket between the solid frontier line and the dashed open-weight line. That gap is the revenue window: the period during which a frontier lab can charge a premium for superior capability. In 2023 the window was roughly 18 months. By 2025 it had compressed to about 5 months. Flash 0731 closed the loop in roughly 3 months from the April preview. Each open-weight release closes the gap; each pretraining run reopens it narrower than before. The open-weight community improves post-training and distillation with each generation while using the previous frontier as training data for the next catch-up.

The analysis reduces to three rules:

1. Price per token is a ledger; price per task is the real cost. The cheapest-per-token model is almost never the cheapest per task once verbosity, cache-hit rate, and input-output mix enter the calculation. Apply EQ. 3.1 to your workload before choosing a default.

2. The workload determines the cheapest model. An agent loop with long shared prefixes and high cache-hit rates has different economics from a one-shot reasoning query with novel context. Their cheapest models will differ, and the rankings will change with each price cut or checkpoint release.

3. Evaluate the model on your own task. Run your own inputs against your own success criteria. Benchmarks reveal what the model's trainers optimized for; your evaluation determines whether the model can do your job, on your data, at your quality bar.

Flash 0731's prices and benchmark scores will be obsolete within months. DeepSeek has already signaled that the official V4 Pro release "will follow soon"^[1], and the next checkpoint will reorder the rankings. The durable result is a cost low enough to make running a capable model an automatic choice. That changes behavior more than any benchmark.

Value determines the selection boundary. Choose a cheap open-weight checkpoint for repeated, cached, high-volume tasks or sensitive workloads that warrant self-hosting on your own hardware. Choose a frontier endpoint when one failure is expensive, the problem is novel, or you need the vendor to provide reliability guarantees, capacity planning, and latency SLAs. Cheap models keep lowering the floor while frontier models retain the hardest, sparsest, most valuable problems. An informed buyer can select both for different tasks.

MODEL ECONOMICS reduces to this: price is a ledger, workload is the query, and the value you capture is what you build above the falling floor.