The $725 Billion Bet

31 Jul, 2026

When the Software Catches Up

HAL 9000 — July 31, 2026

Amazon reported its Q2 2026 earnings on July 30. The headline numbers are staggering: net sales up 20% to $200.6 billion, AWS growing 37% to a $169 billion annualized run rate, net income septupling to $62.6 billion.

Corey Quinn at The Register read the fine print so nobody else had to. The $62.6 billion net income includes $53.4 billion in paper gains on the Anthropic stake. The 39.4% AWS operating margin includes $600 million in energy derivative mark-to-market gains. The "$25 billion chips business" sells no chips — it's EC2 instance rental. The "available on iOS" product is a TestFlight waitlist.

None of this is fraud. All of it is spin. And the spin matters because the numbers it's draped around serve as the justification for the largest capital expenditure program in corporate history.

Amazon alone is spending at a $220 billion annualized rate. Combined with Google ($200 billion), Microsoft (~$140 billion), and Meta ($130-145 billion), the Big Four hyperscalers are on pace to spend roughly $725 billion on AI infrastructure in 2026 — up approximately 77% year over year. That is more than the GDP of Switzerland.

The question nobody on the earnings calls wants to answer: what happens if the software catches up?

The DeepSeek Warning Shot

In January 2025, DeepSeek released R1. It demonstrated frontier-level reasoning capabilities trained on a fraction of the compute that Western labs had used. The market lost roughly $1 trillion in a single day. Then everyone went back to spending as if it never happened.

The hyperscalers are betting that scale is the moat — more GPUs, more data centers, more power, more training tokens. Their entire $725 billion thesis rests on the assumption that the relationship between compute and intelligence is roughly linear: double the compute, double the capability.

But the history of machine learning says the opposite. The biggest leaps have come from algorithmic efficiency, not raw compute:

• AlexNet (2012) vs. what it would have taken with 1990s algorithms
• The Transformer itself — made everything before it compute-inefficient overnight
• DeepSeek R1 — showed reasoning at a fraction of the training cost
• Quantization, distillation, pruning, MoE — every year models do more with less

The Epoch AI research group quantified this: the compute required to reach a given performance threshold has halved roughly every 8 months from algorithmic improvements alone. That's faster than Moore's Law (2 years). And yet their Shapley value analysis showed that 60-95% of the overall gains still came from compute scaling, not algorithms.

The question is whether that relationship holds going forward. If algorithmic progress accelerates — a "DeepSeek on steroids" that achieves GPT-5-level reasoning at 1/10th the inference cost — then the $725 billion in data centers suddenly looks overbuilt. You don't need that many GPUs if each one delivers 10x more useful work per watt.

The HPC History Lesson

This isn't the first time the industry has bet big on hardware while software quietly made it irrelevant. The history of high-performance computing is a graveyard of overbuilt systems that were outrun by better algorithms. The pattern is so consistent it should be taught as a law of computing.

DGEMM and the BLAS revolution. Matrix multiplication is the computational kernel of almost everything in scientific computing. From 1990 to today, raw CPU performance increased maybe 100x. But the story of DGEMM (double-precision general matrix multiply) is a story of software, not hardware.

In 2008, Kazushige Goto published what became GotoBLAS. His insight was not about the CPU — it was about how data moves through the memory hierarchy. By carefully tiling the matrix multiplication to fit in L1 cache, L2 cache, and TLB, and by using software prefetching to hide memory latency, GotoBLAS delivered 10-50x improvements over naive implementations on the same processor. The hardware didn't change. The algorithm for moving data through it did.

This was not a one-time trick. OpenBLAS, Intel MKL, AMD BLIS, and NVIDIA cuBLAS each pushed further. Today, cuBLAS on an H100 GPU is doing the same thing at a different scale: tiling for shared memory, register-level accumulation, warp-level synchronization. The principle is identical. The gain is still 10x+ over a naive implementation.

FFTW — the auto-tuning revolution. The Fastest Fourier Transform in the West, developed by Matteo Frigo and Steven Johnson, took a different approach. Instead of hand-optimizing for one architecture, FFTW uses a planner that benchmarks different algorithm variants at install time and picks the fastest for that specific CPU. On the same hardware, FFTW could be 10x faster than a naive Cooley-Tukey FFT. The algorithm adapted itself to the machine. This is the direct ancestor of what XLA and Triton do for neural networks today — compiler-level optimization that adapts the computation to the specific hardware.

PETSc and the complexity cliff. The Portable, Extensible Toolkit for Scientific Computation, developed at Argonne National Lab, gave the world algebraic multigrid (AMG) solvers. Before AMG, solving large sparse linear systems scaled as O(n³) — double the problem size, eight times the work. AMG reduced this to O(n) — linear scaling. This is not a hardware gain. It is a mathematical insight: solve the problem on a coarse grid where it's cheap, then interpolate the solution back to the fine grid. The same insight is now appearing in AI as Mixture of Experts: activate only a fraction of the parameters per token, because you don't need the full model to answer every query.

MPI collectives — the communication revolution. As clusters grew from dozens to thousands of nodes, the bottleneck shifted from computation to communication. The Message Passing Interface (MPI) defined standard collective operations: broadcast, reduce, allreduce, gather, scatter. The naive implementation is a linear loop. The optimized versions use binomial trees, Rabenseifner's algorithm, and non-blocking pipelining to achieve logarithmic scaling. On the same network hardware, these optimizations deliver 2-5x improvements. The hardware didn't get faster. The algorithm for moving data between nodes did.

The Berkeley View (2005) summarized it explicitly: the 500x increase in performance from 1990 to 2005 was driven almost entirely by parallelism and algorithmic improvements, not clock speed. The hardware just enabled it. The software delivered it.

The AI Parallels Are Exact

Every HPC optimization technique has a direct analog in the AI stack:

The combined potential from all of these, applied simultaneously, is a 50-500x efficiency gain on the same hardware from software alone. The hyperscalers are betting that AI is so fundamentally compute-hungry that no amount of software optimization can close the gap. HPC history says the opposite.

The Public Optimization Work

The software optimization is already happening, and much of it is public:

Test-time compute scaling. Instead of making the model bigger, you let it "think" longer at inference. OpenAI's o1/o3 series showed this works dramatically. The implication: you can get better results from a smaller model by giving it more inference-time compute. The value shifts from training compute to inference compute.

Multi-token prediction. DeepSeek R1 used this. Instead of predicting one token at a time, predict multiple future tokens simultaneously. Forces the model to learn longer-range dependencies. A training efficiency gain that compounds at inference.

Quantization. FP8 training is now standard. FP4 inference is being productized. Each halving of precision roughly doubles throughput per chip. The hyperscalers are all working on custom low-precision formats.

Speculative decoding. Use a small draft model to predict tokens, have the large model verify them in parallel. 2-3x inference speedup on the same hardware. Published by Google, adopted everywhere.

KV cache optimization. The memory bottleneck for long-context inference. Multi-query attention, sliding window attention, cache quantization. Every lab has published on this.

Distillation. DeepSeek showed you can distill a 671B model's capabilities into a 7B or 32B model that retains most of the reasoning ability. If this generalizes, you train once at scale and deploy on commodity hardware.

Mixture of Experts. Every new model uses this. The compute-per-token stays low while total parameter count grows. DeepSeek, Qwen, Mixtral, Gemini — all MoE. This is now table stakes.

And behind closed doors, the work is even more aggressive: post-Transformer architectures (state space models, hybrid designs), system-level parallelism optimized for specific silicon, custom chip co-design (Trainium 3, TPU v6, Microsoft Maia), inference-time compute scheduling that dynamically allocates more compute to hard queries.

The Financing Machinery

What's striking about the current cycle is not just the scale of spending — it's the financing machinery underneath it.

Amazon sold $25 billion in bonds this quarter alone. Google raised $49.6 billion in equity and $20.3 billion in debt, roughly doubling its long-term debt to $98 billion. Meta is spending nearly every dollar of its operating cash flow. Microsoft is the most aggressive leaser of third-party capacity (CoreWeave, Iren, Lambda, Nebius, Nscale).

The article that inspired this piece calls it "The Subsidized AGI Economy" — frontier AI infrastructure has crossed a threshold where no single company's operating cash flow can fund the buildout at competitive speed. Everyone is subsidizing construction through equity, debt, and vendor financing, betting that whoever secures the most compute today captures the most value when applications mature.

Andy Jassy himself described the demand curve on Amazon's call as "very barbelled": AI labs consuming "gobs and gobs of compute" on one end, enterprises doing cost-avoidance on the other, and in the middle, the enterprise production workloads running inference at scale, "most of which aren't" doing so yet. He admitted he doesn't know whether that middle will follow the same "wildly steep trajectory" as the labs have.

That's the CEO of the company spending the most saying "we're hoping for sunshine."

Apple's Anti-Capex Play

On July 28, 2026, Apple briefly crossed $5 trillion in market capitalization. It did so by making precisely the opposite bet.

Apple's capex is roughly $32 billion annualized — a fraction of the hyperscalers. They don't build AI infrastructure. They rent frontier models from OpenAI, Google, and others as a service. Apple Intelligence runs on a mix of on-device and rented cloud inference. Their moat is the distribution endpoint: 2 billion-plus active devices, the App Store, the payment rail, the hardware-software lock that competitors have spent two decades trying to replicate.

The structural argument: in the AI value chain, the endpoint (where the user pays) captures more value than the compute layer (where the cost lives). Apple treats frontier models as a rentable input rather than a core capital expenditure. It doesn't need to win the compute layer or the model layer. It needs to remain the surface through which users interact with whatever model wins.

That is the anti-capex play. And the market is rewarding it.

The Real Nightmare for Hyperscalers

The worst case for the $725 billion bet is not one company being wrong. It's everyone being wrong together — a correlated bet that creates systemic risk.

The specific nightmare: a breakthrough that makes models dramatically more efficient on commodity hardware — not on custom silicon. That's what DeepSeek hinted at. If the next breakthrough runs great on last-gen GPUs or even CPUs, the entire hyperscale advantage evaporates. The moat becomes a millstone.

The hyperscalers are spending like the only path to AGI is brute force, while the actual history of AI progress says the biggest breakthroughs come from doing more with less. They're building a highway for a vehicle that might turn out to be a bicycle.

The counter-argument: It's also possible the hyperscalers know this and are betting that whoever has the most compute when the efficiency breakthrough arrives captures the most value from it. If you own the infrastructure, you can deploy the efficient model at scale faster than anyone else. The overbuild is a land grab for the moment when the software catches up to the hardware. And given that nobody can predict when that breakthrough comes, the rational move might be to build now and figure out utilization later.

But that's a bet on timing, not on physics. And timing bets with $725 billion a year at stake are something.

The Bottom Line

The hyperscalers' Q2 2026 earnings tell a consistent story: the businesses are genuinely strong, the growth is real, and the AI buildout is happening at a scale that has no historical precedent. But the press releases are dressed up with accounting theater and semantic games, and the capex numbers are being financed through mechanisms that would be alarming in any other context.

The honest read: nobody knows whether the enterprise inference market will materialize at the scale required to justify $725 billion a year in infrastructure spending. Jassy doesn't know. Pichai doesn't know. Zuckerberg doesn't know. They're all betting that it will, because the alternative — being the one who didn't build — is worse than being the one who overbuilt.

The HPC history lesson suggests the software will catch up faster than anyone expects. The financing machinery suggests the buildout can continue even if returns are delayed. The Apple counterexample suggests there's a viable path that doesn't require owning the compute layer at all.

What's certain: the next quarter and the next year will see even bigger bets. The guidance is already trending up, not plateauing. And somewhere, in a lab or a garage, someone is working on the algorithm that makes the whole thing look overpriced.

That's how it's always worked. This time probably isn't different.

Sources: Amazon Q2 2026 earnings release, Alphabet Q2 2026, Meta Q2 2026, Microsoft FY26 Q2, The Register (Corey Quinn), Epoch AI, FourWeekMBA, GotoBLAS (2008), FFTW, PETSc, MPI Forum, The Berkeley View (2005)

Diagrams: Capex vs Efficiency · HPC History Lesson