Big Tech's $1.5 Trillion AI Spending Spree Created Small Language Models Now Undercutting It
By Will Melton · August 12, 2026 · 11 min read read
Category: AI

Big tech has spent more than $1.5 trillion on AI infrastructure since 2020. The research it published along the way produced small language models that run free on a laptop, and a practical path to using them.
Big tech has spent more than $1.5 trillion on AI infrastructure since 2020, and close to half of that arrived in 2026 alone.
The acceleration is the real story. Big tech spent about $226 billion on AI infrastructure in 2024, about $410 billion in 2025, and is on pace for somewhere between $700 billion and $800 billion in 2026, depending on which tracker and which companies get counted. One widely cited estimate puts 2026's roughly $725 billion above everything spent on AI infrastructure in the several years before it, combined.
Combined revenue across every frontier AI lab remains a fraction of that figure. Anthropic's run rate went from $87 million in January 2024 to roughly $30 billion in April 2026, one of the fastest revenue climbs on record for an enterprise software company, and the gap still has not closed. Sequoia's David Cahn put the annual shortfall between AI infrastructure spending and AI ecosystem revenue at roughly $600 billion in a widely circulated analysis. It has widened since.
That spending also produced something else: a fully documented, publicly funded blueprint for making frontier-grade AI cheap to reproduce at a fraction of the size.
How the Giants Taught Everyone to Build Small
A frontier model needs three things: an architecture that scales, a training corpus large enough to use it, and enough compute to run the training. The major labs solved all three, then published a great deal of how, because the people doing the work are researchers who publish for a living.
Transformers came out of Google, in a 2017 paper called Attention Is All You Need that now underpins essentially every model in this article. Chain-of-thought prompting, scaling laws, reinforcement learning from human feedback, mixture-of-experts routing, and modern quantization schemes moved through arXiv and NeurIPS the way academic research is supposed to move. Meta went further, releasing full model weights with Llama and turning a research literature into a working ecosystem within about 18 months.
The technique that matters most is distillation. A large model can generate enormous volumes of high-quality synthetic training data, and a much smaller model trained on that output inherits a surprising share of the parent's behavior. Microsoft's Phi series demonstrates this cleanly: heavily curated synthetic data, a few billion parameters, benchmark scores that outperform models several times its size. DeepSeek R1 made the same point in January 2025, reaching frontier-grade reasoning at a training cost that did not require a sovereign wealth fund.
By April 2026, DeepSeek V4-Pro scored 80.6% on SWE-bench Verified, two-tenths of a point off Claude Opus 4.6, under an MIT license, at roughly 10 to 13 times lower cost per output token. Qwen, Llama, GLM, Kimi, and Gemma have traced similar curves. Five independent open-weight model families reached the same ceiling in the same window. That degree of convergence is the signature of a shared technique, distillation from frontier output, spreading through the field faster than any single lab anticipated.
The corpora used to train frontier models raise a separate, litigated question: where the data came from. A federal judge gave final approval in July 2026 to Anthropic's $1.5 billion settlement with book authors, the largest copyright payout on record, after the underlying ruling drew a line between two fact patterns: training on lawfully acquired books was fair use, and training on a corpus the company knew was pirated carried liability regardless. More than 35 separate training-data lawsuits were active in major Western courts as of the second quarter of 2026, tracked in BakerHostetler's running AI litigation database. Hachette, Elsevier, and Cengage sued Google over Gemini the same month the Anthropic settlement cleared.
What a Small Language Model Actually Is
Small, here, means under about 10 billion parameters, small enough to run on a laptop or a single consumer GPU without a data center behind it. A 3-billion-parameter model was a curiosity as recently as 2024. In 2026, models at that scale handle production workloads: coding assistants, document question-answering, local agents, on hardware many developers already own.
Quantization does the heavy lifting. Model weights are stored at reduced precision, commonly a scheme called Q4, cutting the memory footprint by roughly a factor of four with a modest quality cost. A 4-billion-parameter model at Q4 needs about 3 GB of memory.
Nine Small Models Worth Knowing in 2026
Each entry lists the size, what it is good at, roughly how much video memory it needs at Q4, and the exact command to pull it once Ollama is installed.
Phi-4 — 14B, needs 9-10 GB. The best overall small model right now. Scores 84.8% on MMLU and is unusually strong at math. The only model on this list that will not fit comfortably on an 8 GB machine. Pull it with
ollama pull phi4.Phi-4-mini — 3.8B, needs 3 GB. The best reasoner under 4B parameters, at roughly 68% MMLU. Reach for this when reasoning quality matters more than conversational polish. Pull it with
ollama pull phi4-mini.Gemma 4 E2B-E4B — 2-4B, needs 3-4 GB. Google's edge-optimized line. Multimodal, supports 140-plus languages, and has the widest runtime support of anything here. The default pick for phones and edge devices. Pull it with
ollama pull gemma4:e4b.Qwen3.5 4B — 4B, needs 3-4 GB. Alibaba's current small flagship and the best all-around starting point for most people. Text and image input, a 256K context window, Apache 2.0 licensed for commercial use. Pull it with
ollama pull qwen3.5:4b.Qwen3.5 9B — 9B, needs 6 GB. The same architecture with more capacity. Better for coding, function calling, and local retrieval work where you can absorb the extra latency. Pull it with
ollama pull qwen3.5:9b.Llama 3.1 8B — 8B, needs 5-6 GB. The safest general-purpose default, with by far the largest fine-tuning ecosystem and the most community documentation to fall back on. Pull it with
ollama pull llama3.1:8b.Llama 3.2 3B — 3B, needs 2.5 GB. The fastest model on this list. Built for tool calling, structured output, and mobile deployment where speed beats depth. Pull it with
ollama pull llama3.2:3b.SmolLM3-3B — 3B, needs 2.5 GB. Hugging Face's fully open model, training details published. Genuine 128K context, which makes it the pick for long documents on modest hardware.
Ministral 3 — 3B or 8B, needs 3-6 GB. Mistral's current edge line. Text and image input, a 256K context window, and notably strong performance in European languages. Pull it with
ollama pull ministral-3:3b.
For document-heavy vision work specifically, Qwen3-VL-8B is the strongest small option, scoring 96.1 on DocVQA in about 6 GB of memory.
One warning worth flagging: a model advertising 128K context through simple positional interpolation loses quality well before it reaches that length. Check how the context window was actually trained. The full catalog of what will run locally is at ollama.com/library.
What Hardware You Need to Run One
Eight gigabytes of system memory is the floor. A model under 4B parameters runs on CPU alone at 30 to 70 tokens per second, faster than most people read.
Sixteen gigabytes of unified memory on an Apple Silicon Mac, or an 8 GB GPU such as an RTX 3060 or 4060, runs everything in the list above comfortably except Phi-4.
Twenty-four gigabytes of VRAM, or a Mac with 32 to 64 GB, puts 27B-32B models and multi-model pipelines in reach.
Ollama is the fastest way in. Install it, run a single command such as ollama pull phi4-mini, and a working model answers prompts inside 10 minutes. LM Studio offers the same result with a graphical interface. llama.cpp is the engine underneath both, worth learning if you plan to embed a model in something you ship. All three are free.
Where Frontier Models Still Win
Frontier models remain meaningfully better at five kinds of work:
Open-ended reasoning across long, disorganized context, such as synthesizing forty documents into one coherent strategy.
Genuinely novel problems with no close precedent in training data.
Long agentic chains, where a small per-step error rate compounds across many steps.
System-level code architecture, as opposed to code completion inside an established pattern.
Any task where a wrong answer is expensive and no person reviews the output before it ships.
Which Work to Move to a Small Model Now
Six categories of work already run better locally, on cost, speed, and privacy grounds:
Classification and routing. Tagging support tickets, sorting inbound email, scoring leads. A 3B model fine-tuned on your own taxonomy beats a general frontier model and costs nothing per call.
Extraction. Pulling structured fields out of invoices, contracts, resumes, and scanned documents. Qwen3-VL handles the scanned ones.
Summarization at volume. Meeting notes, call transcripts, daily digests. 10,000 summaries a month is a real line item on a frontier API bill and a rounding error in electricity when it runs locally.
Draft generation inside a known format. Product listings, first-pass replies, templated copy that a person edits anyway.
Anything touching regulated or confidential data. The model runs on the machine in front of you. Nothing leaves it, which settles a compliance question that has stalled more than a few otherwise-ready projects.
Offline and edge deployment. Retail floors, manufacturing lines, field work with unreliable connectivity.
How to Fine-Tune a Small Model on Your Own Data
Full pretraining is out of reach for almost everyone and unnecessary for this. What works is fine-tuning, specifically a method called LoRA, or Low-Rank Adaptation, which freezes the base model and trains a small set of additional weights alongside it. A variant called QLoRA quantizes the base model first, dropping memory requirements far enough that an 8B fine-tune fits on a single consumer GPU.
Collect 500 to 5,000 examples that show the behavior you want, pulled from your own archive of past tickets, emails, classifications, or deliverables. This step takes most of the effort and decides most of the outcome.
Clean the examples. Fifty excellent examples outperform a thousand mediocre ones at this scale.
Format them as instruction pairs, one JSON object per line, a prompt and the completion you want.
Choose a base model. Llama 3.1 8B for general work, Qwen3.5 for code, Phi-4-mini where memory is tight. Check the license against how you plan to use the result.
Run the fine-tune. Unsloth is the fastest option on a single GPU and the easiest place to start. Axolotl handles multi-GPU and custom pipelines. Hugging Face's PEFT library is the layer most of them build on. A few hours on a rented A100 costs less than a dinner out, and Google Colab handles smaller runs for free.
Hold back one-fifth of the examples as a test set, never shown during training. Compare the fine-tuned model against the base model and against whatever frontier API call it is meant to replace, on the same inputs.
Deploy through Ollama or vLLM and watch it in production for a month before trusting it fully.
One hybrid approach covers most real cases: use a frontier model to generate and label training examples, then distill that into a small model that runs on infrastructure someone else does not control. That is the same technique the labs used on themselves, aimed at a narrower problem.
Why the Scale-First Playbook May Not Hold This Time
The strategy behind the spending is a familiar one: spend the most, draw the most attention, raise the most money, repeat until the market has one dominant player. It worked for search, for social networking, for ride-hailing, for streaming video. Each of those bets assumed the spending itself was the moat.
Language modeling looks different. The expensive part of the process produces knowledge. Knowledge compresses. Compression is cheap once someone has shown how, and the labs showed how, in public, with citations attached. One major lab gave its weights away entirely as a move against its competitors.
Frontier labs still matter. They remain the source most distillation techniques pull from today, and someone has to build the first version of anything before it can be compressed. What has changed is the assumption sitting underneath a $1.5 trillion, six-year bet: that raw scale is, by itself, a durable advantage. A growing body of open-weight evidence runs against that assumption, produced largely by the same companies making the bet.
For everyone else, anyone not spending hundreds of billions a year on data centers, the practical upside is real and currently unclaimed. The models are free to download. The tools to run and fine-tune them are free. The hardware is very likely already on the desk.
Install Ollama and pull a model tonight. This guide will still be here tomorrow.