Companion to “Reading the board from the stands”. The short essay is about what it did to me. This is the working-out: three value chains at three altitudes — the maps and my thoughts.

Built from the Dwarkesh–Jensen Huang interview, Bryan Cantrill on Oxide, and George Hotz’s tinygrad writing. Sources at the bottom.

1. What Jensen actually said

The interview runs an hour and forty, and a big chunk of it is the China export-control fight. That fight is strategy too — politics is one of the planes strategy is played on, and strategy is always played on several planes at once, which is where the five-layer cake comes from naturally. I take the China fight as a sixth claim at the end; the first five interlock tightly, and every one of them lands cleanly on a Wardley concept — which is exactly why I couldn’t stop mapping it.

One — Nvidia is an electrons-to-tokens transformation company. Dwarkesh opens by needling him: Nvidia is basically a software company, it ships a GDS2 file to TSMC, SK Hynix and Micron make the HBM, the Taiwanese ODMs bolt the racks together. Jensen doesn’t flinch. “The input is electrons, the output is tokens. In the middle is Nvidia. Our job is to do as much as necessary and as little as possible.” That last clause reads like humility and works like doctrine — the north star of everything else he says.

Two — AI is a five-layer cake and he wants to win every layer. Energy, then chips, then systems and networking, then models, then applications. When Dwarkesh tries to argue that conceding China at the chip layer is a fair price for protecting the model layer, Jensen’s rebuttal is essentially that you’re proposing one layer of the stack surrender its second-largest market to protect a different layer, which is strategic illiteracy. The five-layer frame is how he organises nearly every answer.

Three — the supply chain is a moat, but only because it’s an information-coordination moat. This is the one that got me, so I’ll come back to it properly. The visible number is ~$100B in purchase commitments on the filings, with SemiAnalysis estimating it trends toward $250B. But the interesting part is that most of the upstream investment is implicit: the Micron CEO doubled down on HBM because Jensen sat him down years ago and walked him through the demand curve until he believed it. GTC is cast as the industry’s coordination forum — “I bring them together so the downstream can see the upstream.” The moat runs deeper than the purchase orders: only Nvidia has forecasts credible enough to make the upstream commit capacity years in advance.

Four — the bottlenecks aren’t the ones people name. His sharpest “no” comes when Dwarkesh presses on lithography. Doubling revenue is not bottlenecked by EUV machines, because “none of the bottlenecks last longer than a couple of years,” and meanwhile the Hopper→Blackwell jump is 30–50× on energy efficiency through co-design, not transistor scaling. The binding constraints are downstream — energy, plumbers, policy. That’s the five-layer cake talking again: lower layers can be traded off against each other if the layer above is programmable enough to exploit the substitution.

Five — don’t become a hyperscaler; nurture one instead. The most loaded answer in the interview. Asked why Nvidia, sitting on that cash pile, doesn’t just vertically integrate into cloud, he’s doctrinal: “We should do as much as needed, as little as possible. The world has lots of clouds. If I didn’t do it, somebody would show up.” He contrasts it with CUDA, NVLink, the CUDA-X libraries — things where, if Nvidia hadn’t done them, “nobody else would have.” The doctrine underneath: do the thing whose absence leaves a vacuum; for everything else, build a market and ride it.

The China section is the sixth claim, played on the political plane: conceding a market is itself a cost, because it accelerates a rival stack (Huawei + SMIC + CANN + domestic open models) that will eventually contest the other four layers too. I think that’s the correct Wardley instinct even if neither he nor Dwarkesh lands a knockout on it.

2. The map, quickly

For anyone reading this cold: a Wardley map plots a value chain on two axes. The y-axis is visibility to the user — the anchor (the user need) sits at the top, the invisible infrastructure sinks to the bottom. The x-axis is evolution, in four bands: Genesis (novel, uncertain), Custom Built (bespoke, expensive), Product (standardised, many vendors), Commodity/Utility (invisible until it fails, priced like electricity). Everything drifts left-to-right over time under competitive pressure, and almost all the strategic interest is in what’s moving and what moves with it.

Three climatic patterns matter for this. Co-evolution: a component moving right enables new practice above it (commodity compute enabled DevOps). Inertia: incumbents resist a component industrialising when their margin depends on it staying custom (the kit-car enterprise server is the textbook case). Industrialisation-as-attack: the strongest move on the board is to take something competitors treat as Custom and force it to Commodity, collapsing their margin while you sit on the utility substrate — AWS in 2006 is the canonical one.

That’s the whole toolkit. With it, all three strategies snap into focus.

3. Nvidia, mapped — and the six-year drift that finally convinced me

The anchor on Nvidia’s map is something like “run AI workloads that generate economically valuable tokens.” Under it, in descending visibility: models and applications; the training/inference frameworks (PyTorch, vLLM, SGLang, Triton, verl); the CUDA programming model and CUDA-X libraries; the systems layer (NVLink, the NVL72 rack, Spectrum-X); the silicon (Blackwell, Vera Rubin, Feynman); packaging (CoWoS); memory (HBM); the wafer (TSMC N3/N2); EUV (ASML); and at the very bottom, energy and physical plant.

Across evolution:

• Energy, wafer, CPU, DRAM, Ethernet are firmly Commodity/Utility. Jensen treats them as climate rather than strategy — if China has abundant energy, that substitutes for leading-edge chips; if the US lacks it, architectural efficiency has to compensate.
• EUV and HBM are Product drifting to Commodity, which is exactly why he’s so dismissive of EUV as a long-term bottleneck: “Once you can build one, you can build ten, and once you can build ten, you can build a million.” That’s component industrialisation on a 2–3 year cycle, described from the inside.
• CoWoS and silicon photonics are late-Custom / early-Product, and Nvidia is dragging them rightward on purpose — “swarming the daylights out of it” for two years. The Lumentum/Coherent/COUPE investments are doing the same to silicon photonics right now: forcing a Genesis-ish component toward Product faster than organic demand would.
• The systems layer (NVL72, NVLink, Spectrum-X) is Custom Built at the frontier with a Product tail. Every generation re-custom-builds the system while the previous one slides right. “You can count on us every single year” is literally a commitment to re-genesise this layer annually.
• CUDA and CUDA-X are the centrepiece. Product in install-base terms (hundreds of millions of GPUs, every cloud, every framework), but Custom in their ability to absorb new workloads. That deliberate straddle is what he means by “programmability” — CUDA gets to be both the stable substrate and the innovation surface at once.
• Models, frameworks, applications are in every evolution stage at once, which is why he’s happy to watch Triton, vLLM, SGLang, verl, and NeMo RL all proliferate. They’re the Cambrian explosion above his utility layer.

So Nvidia’s revenue engine sits in a narrow vertical corridor — silicon, packaging, systems, CUDA — that it keeps pumping leftward back into Custom every year, while shoving everything below it rightward toward Commodity as fast as the supply chain can absorb the capital. That’s why his forecasting meetings with Micron and TSMC matter more than his keynotes: he’s the only actor with the demand-signal credibility to pull those lower components right.

And here’s the part that broke my dismissal. Take Joaquín Peña Fernández’s 2020 Nvidia map — the only substantive public Nvidia map there is — and plot its fourteen components against where the company sits in 2026. Not a single one drifted left. Eight of fourteen went decisively right. Three got absorbed or went extinct (“general purpose computing is over”). Two stayed static. One — AI itself — got promoted from a component to the anchor. And CUDA didn’t move at all on the evolution axis while its install base grew roughly a hundredfold.

Most companies show at least one regression on a six-year window — a bet that went sideways, a component they tried and failed to push. Nvidia has none. That is the climatic pattern “everything evolves” being ridden by someone who refuses to fight it — a cleaner signature than luck or a bull market could ever leave. CUDA didn’t move, and that is the point — a moat that absorbs the drift of everything around it without drifting itself. The rarest thing on the whole drift map is that the anchor set itself changed: 2020’s anchors were device categories (Autos, Video games, Mobile), 2026’s are user states (augmented worker, sovereign capability, physical autonomy). Redefining what the chain is for is the move you normally only see at the birth of an era. He did it deliberately, and it’s the most consequential thing on the page.

I had been reading evolution for years and never bothered to map the most-mapped company in tech. I just never looked. That is the kind of miss worth admitting plainly.

4. How Jensen plays it

Industrialise the layer below you so it can’t bottleneck the layer above. CoWoS is the purest example — two years of swarming dragged it from specialty packaging to mainstream, Custom→Product under deliberate pull. The same playbook runs for HBM, silicon photonics, eventually EUV. It is the AWS-with-servers move, except he runs it on someone else’s supply chain because he doesn’t want to own fabs.

Keep your differentiation layers perpetually in late-Custom. Every hardware generation re-genesises the systems layer. NVL72, NVLink, Spectrum-X, kernel co-design with the labs — all of it resists the natural rightward drift. The line about engineers embedded in the AI labs, “nobody knows our architecture better than we do,” squeezing 2–3× out of a customer’s existing fleet, is the same pattern: never let the system layer settle into Product, because Product is where the ASICs catch you. And it isn’t just a line. In June 2026 SemiAnalysis’s InferenceX measured GB200 NVL72 serving costs for the Kimi architecture (the one behind xAI’s Cursor Composer 2.5) falling 2.5× in under seventy days through software alone — largely NVIDIA’s own kernel engineers rewriting the NVFP4 MoE kernel in CuTe-DSL to exploit the NVL72 copper backplane, which carries 18× the bandwidth of standard RoCEv2/InfiniBand. Same physical fleet, 2.5× cheaper to serve, because only the people who built the rack can rewrite the kernel down to its backplane. That’s the co-design moat compounding in real time — the systems layer being dragged back into Custom faster than anyone outside the building can chase.

CUDA as the anti-commoditisation anchor. Dwarkesh’s sharpest question — your biggest customers can write their own kernels, so why does CUDA matter? — is a claim that CUDA is sliding from Product toward Commodity. Jensen’s answer is install-base rather than technology: hundreds of millions of deployed GPUs across every generation and every cloud; the richness of the contributing ecosystem; being everywhere so developers never have to choose. That’s deliberate — install base is the one axis that doesn’t evolve leftward. A programming model can be re-implemented; hundreds of millions of deployed sockets cannot be re-created.

Refuse vertical integration into hyperscaling. Becoming a cloud means owning a layer that’s already Commodity, fighting four players with a decade head start, and turning your own customers into competitors. So instead he funds the neocloud tier — CoreWeave, Nscale, Nebius, Crusoe — backstopping CoreWeave up to $6.3B, $2B in directly, so a diverse Nvidia-native utility layer exists without Nvidia owning a watt of it. This is ecosystem-as-moat, executed with balance-sheet muscle rather than doctrine alone.

Don’t pick winners at the model layer, even though you could. He invests in all the labs (OpenAI ~$30B, Anthropic ~$10B as reported) precisely so he doesn’t have to know which one wins. His stated reason is humility — “when Nvidia started there were 60 3D graphics companies, we’re the only one that survived, and we’d have been at the top of the list not to make it.” The Wardley reading is sharper than humility: the model layer is Genesis, Genesis has a failure rate you can’t predict, so the correct move is to fund the whole distribution and harvest compute from all of it. The Anthropic-on-TPU “regret” he voices is the regret of not having had the balance sheet to run that strategy sooner.

The China argument, in map terms. Export controls push China to build its own vertical stack — abundant energy, SMIC 7nm, Huawei CANN, domestic open models — which over time industrialises an alternative utility substrate. Once it exists and exports to the Global South, the Middle East, Africa, Southeast Asia, it becomes the default there, and the install-base moat is undermined not in the US but everywhere outside it. Dwarkesh counters that the near-term cyber-offensive risk justifies the price. Nobody lands the knockout. But Jensen’s instinct — that conceding a market accelerates a competing stack’s evolution rather than freezing it — is the same instinct that made him fund the neoclouds instead of letting the hyperscalers monopolise demand aggregation. It’s coherent all the way down.

One honest caveat before I leave Jensen, because I keep turning it over. The move I admire most — the directed investment that locks up custom, non-fungible TSMC capacity, the coordination that gets the whole chain to commit years early — is the same move that, under a demand shock, turns the moat into a bullwhip. A barrier built from non-fungible supply is a magnificent wall while demand holds and pure stranded cost the moment it wobbles. I come back to it in the risks, because it’s the sharpest thing anyone has said against the position, and it’s aimed precisely at the part of his game I find most impressive.

5. Oxide, mapped

Oxide is interesting precisely because it doesn’t compete with Nvidia on anything. Cantrill has been explicit about why, and it’s the cleanest piece of strategy in the whole story: with Nvidia you either work with them or you compete with them, both are brutal, and because the stack isn’t open there’s no real value in it for Oxide either way. So they go somewhere else entirely — a different altitude, a different theory of evolution, a different target. That is reading the board and declining a fight you cannot profit from — the opposite of avoidance.

The anchor Oxide is serving is “run our own cloud, on our own premises, without the kit-car tax.” The customer already spends meaningfully on infrastructure — a bank, a telco, Samsung — and has hit the wall where they’re paying hyperscaler rents for hyperscaler convenience but their workloads don’t actually want to live there.

How I read their map:

• The user-facing API (console, CLI, Terraform provider, Kubernetes compatibility) is Product, deliberately AWS/GCP-shaped, because that’s what their customers’ engineers already know. This is the part they refuse to reinvent.
• The integrated control plane (Rust, Illumos/bhyve, OpenZFS, on-rack VPC, block storage) is Custom Built stretching to Product — bespoke to the Oxide rack but industrialised relative to stitching OpenStack or VMware together.
• The rack-scale system (DC bus bar, blind-mate backplane, 80mm fans at 2K RPM, 32 sleds, 2048 cores, integrated networking) is Custom Built, on purpose. This is the actual bet: that the rack, not the 1U/2U box, is the correct unit of design, and that the industry has inertia preventing the move.
• The network switch (Tofino 2 + custom NOS on AMD) is Custom Built — the decision that defines the company and the reason Cantrill jokes they’re “nine startups within one startup.”
• The BMC / service processor (custom silicon, Hubris real-time OS, no American Megatrends BIOS) is deep Genesis/Custom — the part where they’re most philosophical, treating proprietary firmware as the original sin of the server.
• CPU (AMD Epyc), DRAM, NVMe, the Tofino ASIC are bought as Commodity/Product. Oxide isn’t a silicon company and doesn’t pretend to be.
• Energy, floor, colocation is utility — partnered out to CoreSite and friends.

The shape is the opposite of Nvidia’s. Nvidia’s differentiation is a narrow vertical corridor in the middle of the stack. Oxide’s is smeared wide and shallow — firmware, OS, hypervisor, network OS, rack mechanicals, control plane — anchored by a deliberately conventional API at the top and commodity silicon at the bottom.

I’ll be honest about what I got and what I didn’t. Oxide always interested me — the ways of working, the culture, the engineering taste are exactly my kind of thing, and I’d been following them for that long before I followed them for the strategy. What I didn’t get was the strategy — I could not read why the niche would hold. That changed the moment Simon Wardley, on one of the weekly Discord calls we ran for a while, walked through why there’s a structural niche for an integrated on-prem computer even in a world where cloud and serverless completely won. The utility substrate doesn’t eat everything; it leaves a pocket for the customer whose economics have inverted. Once I could see the pocket, the whole wide-shallow band made sense. I had the culture from day one; I needed the map for the strategy.

6. How Cantrill plays it

Industrialise the hyperscale rack. The thesis is that AWS, Google and Meta discovered years ago that the rack is the correct unit of design and kept that knowledge inside their walls. Dell/HP/Supermicro have enormous inertia against rack-as-unit because their margin depends on selling 1U/2U boxes. Oxide takes a component that exists only as Genesis/Custom inside hyperscaler walls and drags it into Product for everyone else — AWS-2006, one layer up. “It is basically a racked personal computer” is the rhetorical version: a claim that the server industry has been sitting on a component that refused to evolve for 25 years out of incumbent inertia.

Attack the firmware layer specifically. Cantrill’s animus against AMI BIOS — it “somehow remained at the brainstem of server-side computing” — is strategically coherent. Proprietary firmware is a Custom component frozen by an oligopoly; nobody industrialises it because the vendors make more leaving it opaque. By open-sourcing Hubris and the whole firmware path, Oxide forces the component rightward, which unlocks all the integration above it. The layer below you is stuck, so you unstick it yourself.

Bundle the licence problem out of existence. Traditional on-prem means buying VMware, a switch NOS, a BMC licence, a hypervisor, storage software, a management console — each with its own terms and renewal date, all Product-stage components the vendors prevented from collapsing into utility. “Everything included, one SKU” is industrialising the licensing layer. The customer reads it as simplification; strategically it’s a co-evolution play against the entire on-prem software stack.

The AWS API as an anti-pattern moat. The console and API are deliberately AWS-shaped because the shape of the cloud API is now Commodity and inventing a different one would be fighting gravity. Riding the commoditised shape frees the custom-build budget for the layers that matter — rack, switch, firmware. This is structurally identical to Nvidia letting Triton and PyTorch live above CUDA: a commodity interface above your custom layer is a feature rather than a threat.

Sell to customers who already lost the kit-car patience. The target is the customer running thousands of cores who has internalised that the hyperscaler bill is a tax, rather than the long tail of enterprise IT. Samsung buying Joyent (where Cantrill’s experience came from) is the archetype: cloud spend large enough that “go on-prem or die” became the CFO’s mental model. This is a narrow market rather than a mass one — they had shipped under 20 racks as of mid-2024 — and that is Wardley-fine: harvest the segment where willingness to pay for integration is highest, while the integrated-rack category climbs its S-curve.

7. tinygrad, mapped

tinygrad is the case that makes the whole thing interesting, because it points its weapon directly at the layer Jensen spent the interview defending. The mission, on the front page and in the deck, is “we will commoditize the petaflop.” That is a Wardley sentence rather than marketing — “commoditise X” means force X from Product to Commodity, collapsing the margin of whoever sits on X. Hotz is describing the AWS-2006 attack pattern aimed one layer up: at the CUDA/ROCm programming model rather than the hardware.

The anchor is “train or run a model on whatever GPU I can actually buy” — without Nvidia’s supply allocation, without paying 70%+ CUDA rent, without owning the hyperscaler toolchain to get good performance. The customer is the researcher, the small lab, the openpilot-style embedded deployment, and aspirationally any hardware vendor who wants a framework that runs on their silicon without rebuilding PyTorch’s whole compiler surface.

How I read the map:

• The PyTorch-like Tensor frontend is deliberately Product. Like Oxide with the AWS API, Hotz rides the commoditised user surface so he can spend his design budget elsewhere.
• The 12-op UOps IR is Custom Built with Genesis ambitions — the distinctive bet. Where CUDA is Turing-complete because GPUs are general engines, tinygrad’s IR has exactly twelve ADD/MUL primitives with static memory access only. x[3] is allowed; x[y] is not. The claim is that neural networks provably don’t need Turing-completeness, so paying for it — caching, warp scheduling, ISA-level branch prediction — is pure waste. Strip the feature that forces the layer to stay Custom, and the layer below gets cheap to replace.
• The lazy graph rewrite + op-fusion engine turns the constraint into the advantage: twelve ops and no hidden control flow means the compiler sees the whole computation and can fuse a full forward+backward pass into one kernel. Custom Built, pointed at Product.
• The “AM” userspace AMD driver is the most Wardley-interesting node — ~12,000 lines that memory-map AMD GPU registers directly and bypass ROCm entirely. The bounty for an RDNA3 assembler within 10% of LLVM is the last missing piece of a fully sovereign stack. This is the node the “force-it-to-commodity” arrow actually comes out of.
• Backend codegen for PTX, RDNA3, Metal, Qualcomm is Custom Built but explicitly portable — “if you can schedule a dozen basic ops on your ASIC, you can run LLaMA on it tomorrow morning.”
• tinybox (~$15K, 6× Radeon 7900 XTX) is Product but deliberately not the money: “we make money selling computers for more than they cost to make.” The box is a distribution vehicle for the software rather than the product.
• Consumer GPUs, PCIe chassis, PSU, wall power are fully Commodity. Part of the thesis is that the substrate is already good enough — the $999 7900 XTX has the best FLOPS-per-dollar going; the only reason nobody in ML uses it is that the software doesn’t work. Exactly the thing mapping is built to surface: a component already commoditised on one axis (price/perf) held back by an adjacent component (driver/runtime) that refused to industrialise.

8. How Hotz plays it — and why I don’t buy it as strategy

I want to be fair, because the target is correct and he was correct early. But “saw the right target” and “has a strategy” are different claims, and the evidence pulls them apart.

Start with where he’s genuinely right.

He found the load-bearing assumption. CUDA is Product because it’s general-purpose, and general-purpose is expensive because it carries features most NN workloads never use. Restrict the programming model to what neural nets provably need and the compiler gets whole-graph visibility while the silicon has far less to support. Hotz named the exact feature — Turing-completeness — that keeps CUDA pinned in Product, and is building a deliberately less-general alternative that’s strictly more industrial. As a piece of analysis it’s the cleanest example of feature-minimisation as a commoditisation vector I can point to in recent compute. The whole framework is 18,935 lines as of his December 2025 post — about 20,000 cleaned up. The entire assault on a stack measured in the millions of lines fits in a codebase you can read over a weekend.

He’ll write the driver nobody else will. Their sovereign AMD stack — driver, runtime, libraries, emulator — is roughly 12,000 lines that memory-map the GPU directly and skip ROCm entirely. AMD publishes enough docs to do this; ROCm just never got good. Anyone could have built a clean userspace driver; nobody did, because no party in the existing market had the right mix of skill, hunger, and willingness to take zero revenue for two years. This is negative-space arbitrage: the component stayed stuck because the incentives were wrong, and never because it was hard.

Software first, chip later. His five-year post is genuinely sharp: “Only a fool begins by taping out a chip; it’s expensive and not the hard part. AMD, Amazon, Tesla, and Groq have taped out fine chips, but only Google and NVIDIA chips have ever been seriously used for training. Because they have the software.” Reading the AI-ASIC graveyard as a compiler failure rather than a hardware one is real map literacy. If the stack matures, any chip startup sitting on good silicon with no ecosystem gets a software path overnight.

Now comes the part that stops me calling it strategy.

Look at how the target actually arrived. tinygrad started in October 2020 as a toy to teach himself neural nets. The CUDA fight came to him through comma.ai — openpilot had to run its driving model fast on whatever embedded GPU was in the car, not an Nvidia datacentre part, and tinygrad on a Snapdragon 845 turned out roughly 2× faster than Qualcomm’s own SNPE. He’s the guy who unlocked the first iPhone and jailbroke the PS3; closed systems are simply what he breaks. So “disrupt CUDA” arrived as the next closed system, handed to him by a concrete need, rather than deduced from a map. That is the “lucky he saw it” part, and the seeing deserves full credit — the point is that it came from temperament and circumstance rather than from a plan.

And the execution stays temperament all the way down. The company has raised exactly one round — $5.1M on a convertible note in June 2023 — and nothing disclosed since. Five years in, the public repo has real pull — about 33,000 GitHub stars and an active contributor base — but it’s still at version 0.13 as of May 2026: genuine mindshare, still short of a 1.0 anyone bets a company on. The hardware business does “about $2M revenue a year” by his own account in the same December 2025 post; the tinybox is openly a distribution vehicle rather than a margin engine. Hiring is only through merged pull requests — “invest with PRs.” The final mile of the sovereign stack, the RDNA3 assembler, is posted as a public bounty: get within 10% of LLVM, collect a thousand dollars. And the most visible “strategy” moment of the whole project was March 2024, when the tinybox Red’s 7900 XTXs kept crashing on AMD’s closed MES firmware and Hotz’s move was to publicly dare Lisa Su to open-source it — which got him a personal “the team is on it,” patched firmware, and a later MI300X sample, but no open firmware and no partnership. He won a support ticket by going loud.

Set that next to Jensen sitting the Micron CEO down for three years until an entire memory roadmap bent toward a demand curve only Nvidia could see. That is what forcing a layer looks like when it’s a strategy: a second actor convinced, capacity committed, the whole chain moved on purpose. Hotz has none of that machinery and isn’t trying to build it. He has a brilliant, tiny, correct codebase, a $2M hardware side-business, and the bet that if the work is good enough the flywheel starts from the margin. Sometimes it does — and if it does here, he was right first and I’ll say so out loud. But “be brilliant and correct and route around the incumbent and wait to be adopted” is a posture rather than a plan, and the difference between the two is the entire subject of this piece.

9. Where the three converge, and where I think they don’t

On the surface the philosophies rhyme. Jensen’s “as much as necessary, as little as possible,” Cantrill’s “it takes the whole stack to build a cloud computer,” Hotz’s “the best part is no part” are all statements about where to draw the vertical-integration boundary. But they resolve in three different directions, and the maps say why.

Jensen’s “as little as possible” works because Nvidia sits above a supply chain other people are already industrialising. Every component below is drifting right under its own steam; his job is to accelerate it, not own it. The integration he refuses — hyperscaler, foundry, model lab — is integration into layers that are already Product or Commodity, where the marginal return is low and the brand-damage risk (competing with your customers) is high.

Oxide’s maximal integration is necessary because it sits above a supply chain that refused to industrialise. Commodity server hardware doesn’t deliver hyperscale benefits because the chain locked a bad equilibrium — BIOS, BMC, 1U/2U, white-box-switch-plus-vendor-NOS — into Product and stopped. The only way through the inertia is to do all the integration yourself. “Nine startups inside one startup” is the cost of operating in a stuck market.

tinygrad’s minimalism works because it sits below a commoditised stack (PyTorch API, consumer GPUs, wall power) and above a substrate (AMD silicon) whose hardware is fine but whose software is broken. Hotz only has to write the thin wire connecting two already-good components that a market failure kept apart — his position never asks him to re-integrate the world. “Best part is no part” is the doctrine of that position.

Three things fall out of putting the maps side by side.

Oxide and tinygrad are attacking the same pathology from opposite ends. Oxide’s target is the server that never industrialised because the vendors made more leaving it custom; tinygrad’s target is the GPU driver that never industrialised because Nvidia made more leaving it CUDA-shaped. In both cases the component is technically at Product but economically frozen, and in both cases the move is to force it to Commodity from outside the oligopoly. Oxide does it with firmware and racks; tinygrad with drivers and compilers. The shape is the same; only the altitude differs.

All three ride a commoditised API upward as a budget-saver. Nvidia lets PyTorch/vLLM/Triton proliferate above CUDA; Oxide ships an AWS-shaped console; tinygrad ships a PyTorch-shaped frontend. None of them reinvents the user’s entry point; all three spend their custom-build budget further down.

Nvidia is the thing both refuse to buy from, at completely different altitudes. Oxide doesn’t want Nvidia’s hardware because an AI-focused rack is wrong for general on-prem compute. tinygrad doesn’t want Nvidia’s programming model because CUDA’s generality is the tax. Neither is a direct competitor — Oxide won’t ship training rigs, tinygrad won’t sell racks — but both are saying, at their own layer, “the thing Jensen sells has too many features and we have the discipline to ship a stripped version most of the market will eventually prefer.” That is structural pressure rather than competitive pressure. The Anthropic-on-TPU deal is a competitor; tinygrad and Oxide are something different — early signs that the stack Nvidia occupies has Product-stage components that could, in principle, be forced toward Commodity.

But “in principle” is doing a lot of work, and this is where my ranking comes back. Jensen is actively forcing his board, every year, with a coordinated supply chain behind him. Oxide is forcing a real but bounded niche, and knows it. Hotz has the right target and is mostly waiting for physics and the open-source gods to do the forcing for him. The map literacy is the same across all three; the odds of execution are wildly different.

10. What could break each thesis

Nvidia — and the bigger risk hides beneath the one a maps person reaches for first.

The deeper risk is that the demand Jensen is coordinating the whole chain around is partly a bezzle. This is Michael Burry’s “Heretic’s Guide Part III” thesis, and once you put it on a map it’s hard to unsee. The “insatiable AI demand” the bulls cite is inflated by tokenmaxxing — a temporary, leaderboard-driven training-and-benchmarking phase whose real mechanic is enterprises racing to harvest traces to train their own in-house models. It sits in Genesis on the value chain and is, by design, temporary: in Wardley terms it’s the Leverage phase of a hyperscaler Innovate-Leverage-Commoditize play being mistaken for steady-state demand. And that distorted signal bullwhips straight upstream into the exact move I praised — Nvidia’s directed investment into custom, non-fungible TSMC lines. Burry puts the forward purchase commitments at $182B, roughly $119B of it with a single customer, more than Nvidia’s annual operating cash flow. Non-fungible capacity is a wonderful barrier while demand holds and stranded cost the instant it doesn’t. The receivables tell he flags — the top customer’s A/R growing 13.4× against 4.9× revenue, inflecting up as a share of receivables while down as a share of revenue, “a zig where there were only zags” — is the weak signal that the Leverage phase is being pulled forward to beat the print. Underneath it all is a duration mismatch: GPUs economically obsolete in under a decade, the data-center debt behind them running 15–19 years, taken out through an offshore chain of data-center ABS, private credit, and Bermuda captive reinsurers, with power as the real rate limiter (a ~19 GW shortfall by 2028). And here’s the twist the SemiAnalysis number sharpens: efficiency itself is compression — a serving cost falling 2.5× in seventy days means each financed GPU does far more far sooner, great for Jensen’s TCO case and brutal for anyone who overbuilt non-fungible capacity against a temporary signal, because the same co-design win that deepens the moat also thins the demand for the capacity it’s already committed to. All of this leaves AI real and Jensen right about evolution; the claim is narrower. The single most impressive thing about his game — the coordination that makes an entire supply chain commit years early — is also the mechanism that maximises the damage if what it is committing to turns out to be the benchmarking phase rather than the steady state. The better he coordinates, the more he strands when the signal breaks. Mastery and fragility turn out to be the same move seen from two sides, which is the most interesting thing I can say about him, and the reason the admiration in the short essay isn’t the whole story.

The shallower, slower risk is the CUDA one. If the hyperscalers’ custom kernel stacks (OpenAI’s Triton work, Anthropic’s TPU training, Google’s JAX/XLA) mature to genuine substitutability at their level — or a minimal stack like tinygrad’s becomes the reference compiler for non-Nvidia silicon — then Nvidia defends on perf/TCO alone, a quantitative fight against ASICs with 65% margins instead of its own 70%+. His answer — that perf/TCO on InferenceMAX and MLPerf is uncontested and the ASIC vendors decline to show up — is strong near-term and fragile long-term. The Anthropic/TPU multi-gigawatt deal is the obvious canary; tinygrad’s sovereign AMD stack is the less obvious, more structural one. But next to the bezzle, this is the comfortable risk — the one that plays out over years, and the one Jensen can see coming.

Oxide. The early-Product question is behind them — the racks ship and the niche is real. The risk that remains is the size of the pocket: Oxide can be brilliant and still be structurally capped if the integrated rack stays a niche for customers who hit specific on-prem walls rather than becoming a mainstream Dell/HP replacement. The counter-factual is that GPU-heavy AI workloads force the hyperscalers’ own integrated racks (GB200 NVL72 et al.) to become the category reference, leaving Oxide a real but bounded general-compute pocket.

tinygrad. The risk is the one Jensen names without naming tinygrad: the CUDA moat is an install-base moat rather than a technical one, and technical elegance does not evict install bases. tinygrad can be provably better at compiling NN workloads and still fail against hundreds of millions of deployed sockets, thousands of CUDA-tuned research codebases, and a decade of habituated muscle memory. The pessimistic scenario is Plan 9: objectively cleaner than Unix, a niche curiosity for thirty years. The optimistic one is a handful of chip startups with decent silicon adopting the tinygrad stack as their default compiler and the flywheel starting from the margin. Which one obtains should be visible within three years.

And notice what the June 2026 NVL72 result says about where the moat actually sits. tinygrad aims at CUDA’s generality — the Turing-complete “tax.” But that 2.5× came from system co-design rather than from generality: an embedded kernel team rewriting an FP4 kernel in CuTe-DSL to one specific rack’s copper backplane. A portable, rack-less, kernel-team-less stack can’t answer that, however clean its IR is. Hotz can be completely right that neural nets don’t need Turing-completeness and still be aimed at the wrong layer of the wall — the generality, when the load-bearing part is the rack-plus-kernel-team co-design loop.

And a cross-cutting risk for both challengers: each bets its downstream will accept a new API surface shaped like the incumbent’s — Oxide that enterprise devs treat its rack like an AWS region, tinygrad that researchers treat its frontend like PyTorch. Nvidia has mostly already won that fight and doesn’t have to. All three are pushing for the interface they control to become the Commodity interface at its altitude. That’s the real long game for each — even though the layers are completely different and none of them, in any conventional sense, competes with the others.

Further reading

• Dwarkesh Patel, Jensen Huang interview transcript.
• Simon Wardley, Value chain mapping – finding a path, Computer Weekly.
• Oxide Computer, The Cloud Computer.
• Bryan Cantrill on Software Engineering Radio #709 — the Data Center Control Plane.
• The Pragmatic Engineer, Startups on hard mode: Oxide Part 1 – Hardware.
• George Hotz, Five years of tinygrad.
• George Hotz, the tiny corp raised $5.1M — the original “commoditize the petaflop” essay.
• Latent Space, Commoditizing the Petaflop — with George Hotz.
• Phoronix, Tiny Corp Nearing Completely Sovereign Compute Stack For AMD GPUs.
• Tom’s Hardware, AMD’s Lisa Su steps in to fix driver issues with TinyBox AI servers — the March 2024 firmware standoff.
• Joaquín Peña Fernández, A Wardley map of the company NVIDIA 2020 (CC BY-SA 4.0).
• Michael Burry, The Heretic’s Guide to AI’s Stars Part III — Tracepalooza & the Bezzle, Cassandra Unchained — the financing / bezzle counter-thesis.
• SemiAnalysis, InferenceX™ — the June 2026 GB200 NVL72 serving-cost measurement (2.5× in <70 days on the Kimi architecture, via a CuTe-DSL NVFP4 MoE kernel rewrite).

Analyzed and edited with AI and swamp.