Jensen Huang giving a masterclass on why open-source AI matters, and why, by extension, the $NBIS token factory thesis gets more important as AI moves into cyber defense against Mythos-class models:
“The answer to that, as it turns out, is not another Mythos. The way you defend against a super force is not with another super force. It’s with an abundance of cheap force.
And so the best answer for Mythos is actually open source.
Open source so that we have swarms of white blood cells. We have swarms of white blood cells, and these white blood cells are trained to detect and alert us of threats.
And the moment that it detects threats, it figures out where the threat is coming from and closes the door.
And so you can’t count on the fact that your AI is better than their AI, but you can count on the fact that you got more AI than they got. That you can count on.
And so the number of defenders we can have, so long as they’re open source, because open source is cheap, open source models are very good now.
And we can run all of these open source models trained on defending ourselves, and that’s the swarm, the dome if you will - the cybersecurity dome.
And so that’s the answer.”
Not sure many people are thinking about this:
Most AI models today are either language models trained on text, or multimodal models trained on text and images.
But the AI economy has barely tapped into true video/world models trained on real video.
And the reason is simple: compared to text, image data is roughly 10–100x larger, while video data can be 100–1,000x larger.
Data centers and energy infrastructure are already struggling to meet demand for text and image model applications.
And video is next level, it burns 10x+ more tokens, which makes most use cases uneconomic at today’s compute prices.
But video/world models are mission-critical for some of the biggest AI applications: robotics, autonomy, entertainment, simulation, gaming, and industrial automation.
Without a massive ramp in compute capacity worldwide, I don’t see how we get usable video AI applications like robotics at scale any time soon (mind the hyper CEOs). Maybe I’m wrong, but the math does not really add up.
If video/world models are up to 100x more compute-intensive, and we are already capacity-constrained serving mostly text and image models, then we are likely still at much less than 1% of the eventual video AI economy.
Note: I’m talking about data scale here, not stock prices.
All this is just to say how early we are in data center infrastructure and memory.
Looking very, very bullish for $NBIS.
(Not investment advice.)
Open source models are no longer the risky choice. Blind execution is.
For most of the last three years, the cautious move in production AI was the closed endpoint. It worked out of the box. It hid the complexity. The pricing sheet was honest about the bill, if not about the behavior. That tradeoff made sense when open weights still lost on coding, reasoning, and long context by enough that the gap was the story.
Sometime in 2025 the gap stopped being the story. The leaderboard kept moving. Open and closed converged on the work that most production teams actually run. The headlines kept fighting about benchmark deltas the user could no longer feel. The bottleneck moved underneath the model, and almost no one in the public conversation about AI moved with it.
The thing I keep noticing, from inside @nebiustf, is that the bottleneck has the same shape it always has when an industry stops being about a product and starts being about a conversion.
Consider a 1880s oil refiner. By that point, crude was widely available. The well was no longer where the margin sat. The margin sat inside the refinery, in the cracking process, in how many gallons of gasoline came out of each barrel, in how much waste heat was used productively, in how little was lost to flaring. Two refineries fed by the same Pennsylvania crude, by the same labor, with the same machinery, could produce wildly different margins depending on the engineering of the conversion. Standard Oil's durable edge was not that it owned the wells. It was that it operated the refineries roughly 20 percent more efficiently than the competition, and that 20 percent compounded for 30 years.
The token factory is the refinery of this industry. The crude is electricity. The intermediate product is compute. The final product is intelligence. Every step in between is a conversion, and every conversion has a yield. Two sites fed by the same power, running the same chips, serving the same model, will produce wildly different volumes of useful tokens depending on the engineering of the conversion.
The line that ought to keep more product teams awake at night is the application of that math to their own bill.
If you are shipping AI in 2026, you are running a small refinery whether you know it or not. The crude is your API budget. The intermediate product is the inference your application consumes. The final product is the verified work your customers pay for. The yield is the ratio between the dollars going in and the work coming out. That ratio is the business.
A closed API hides the yield.
This is the part that did not show up clearly in the leaderboard era. The endpoint reports a tokens-per-second number and a price-per-million number. Both are accurate, and both are nearly useless for understanding the actual economics of a real workload. The reason is that an endpoint is not one machine. It is a stack of decisions made by someone else about prefill, decode, KV cache reuse, batching, replica placement, speculative decoding, structured output validation, and data residency. Every one of those decisions changes the yield of your specific workload, and none of them are visible from outside the fence.
A few of those decisions, looked at honestly, are doing most of the work.
Prefill and decode are not the same problem. Prefill loads the full context and is compute-bound. Decode generates one token at a time and is memory-bandwidth-bound. Long contexts make prefill dominant. High concurrency makes decode fragile. A serving stack that treats them as one workload looks healthy on the mean and collapses on the tail. The user feels the collapse. The dashboard does not.
KV cache reuse is the economic engine. In agent loops and chat sessions, somewhere between 85 and 95 percent of the tokens in any given turn are repeated from earlier turns. The same system prompt. The same tool definitions. The same repo map. The same customer context. The model does not need to think about most of those tokens again, but if the serving stack does not preserve cache locality across the session, the model thinks anyway, and you pay anyway. Distributed KV pools in production have cut effective cost on multi-turn agent workloads by roughly 50x by routing requests to where the cache already lives. The endpoint will not tell you whether your cache is being reused. It will tell you the bill went up.
CPU is the bottleneck nobody is pricing. Recent measurements out of Georgia Tech and Intel show that in real agent workloads, between 83 and 89 percent of end-to-end latency is CPU-bound. The GPU sits at roughly 10 percent utilization waiting for tool calls, retrieval steps, and verification loops to come back. Upgrading the GPU widens the gap. The thing that determines your unit economics is not even the chip the API is selling you. It is the orchestration layer the API does not show you.
Tail latency is the actual SLA. Users do not experience averages. They experience waits. The P99 latency on a long-context agent under sustained load can be five to ten times the P50. Adding replicas helps the P50. It rarely fixes the P99. Execution paths matter more than throughput numbers, and execution paths are decided inside the stack you do not own.
Speculative decoding is not a speed trick. It is a worst-case bound. A workload-shaped draft model can reduce the number of expensive decode steps on the critical path by an order of magnitude. A generic draft helps. A draft tuned to your traffic helps more. This is the kind of detail that is invisible from outside a serving stack and decisive inside one.
Cache locality is product design. Session affinity, prefix structure, replica placement, retry behavior under load. These used to be plumbing concerns. In 2026, they decide whether your product survives its second order of magnitude of traffic.
Sovereign inference is no longer marketing. Regional isolation, zero retention, and audit trails are becoming line items on enterprise contracts faster than most teams have noticed. Where your data lives, how long it lingers, who can subpoena it. The closed endpoint answers those questions in a way you do not control. The owned stack answers them in a way you can put in a contract.
This is what a refinery you do not own feels like. The model is the same. The bill is yours. The conversion is theirs.
The point is not that everyone should self-host. Most teams should not. Building a serving stack is a real engineering investment, and most product teams should be writing product. The point is that the middle ground is no longer optional. Between raw self-hosting and an opaque endpoint, a third path is forming. Managed inference for open weights. Dedicated capacity. Cache-aware routing. Tunable speculative decoding. Disaggregated prefill and decode. Regional isolation and zero retention by default. Open model. Owned conversion.
The risk moved when the buying decision didn't.
If you are still defaulting to a closed endpoint in mid-2026, the question is not ideological. It is the same question Standard Oil's competitors should have been asking in 1885. Who owns my refinery, and how much of my margin is leaving the building because of that.
The model lives in the cloud & the factory lives behind a fence. If the fence is not yours, neither is the yield.
“Don Tzu”—a ghost strategist of the internet—just dropped a take so sharp it cuts deeper than most think tank reports on Hormuz. Whoever’s behind it clearly sees the chessboard others are missing…