Capital spending is accelerating. GPU order books are full. Earnings calls project confidence. And yet, operators quietly describe delays, partial rollouts, and systems that exist on paper but not yet in practice.

Depending on which signals you emphasize, AI capacity appears either to be exploding or running into hard constraints. Both interpretations are plausible. Neither is sufficient on its own.

This confusion is not a failure of analysis. It is a failure of observability. We are trying to understand a system that spends a long time in a state where capacity is real and paid for, but still not usable—and most of our tools are poorly suited to see that phase clearly.

The Hidden Middle State

Most discussions of AI infrastructure rely on a simple mental shortcut: capital goes in, capacity comes out.

In reality, there is a long and unavoidable middle state. Hardware is ordered, delivered, racked, and powered, but not yet productive. Clusters exist without running sustained workloads. Capacity is present, but fragile.

This is not inefficiency. It is how large technical systems behave under rapid expansion.

AI infrastructure does not move on a single timeline. Spending, physical delivery, and usable capacity advance on different clocks. From a distance, those clocks appear synchronized. Up close, the gaps between them matter enormously, especially during periods of aggressive build-out.

This is where most misinterpretation begins.

Integration Throughput Sets the Pace

The dominant constraint in AI is usually framed as GPU supply. That framing is not wrong, but it is incomplete.

The real pacing factor is integration throughput: the system’s ability to turn purchased hardware into stable, high-utilization clusters. That process is constrained by power provisioning, cooling, networking fabric, software validation, monitoring, and organizational readiness.

Any one of these can slow progress. Often, several do at once.

This is why capacity does not scale linearly with spending. You do not simply buy compute—you integrate it. Integration is a throughput problem, not a procurement problem, and throughput improves unevenly across organizations.

Some teams are better positioned than others. Prior infrastructure investment, standardized architectures, and operational maturity matter. Even so, no one bypasses this phase entirely. Every operator spends time with capacity that technically exists but does not yet behave like a reliable system.

Why the Numbers Don’t Show It

If integration throughput explains the operational bottleneck, accounting explains why it is so often misread from the outside.

Financial statements are not designed to capture partially integrated systems. Construction-in-progress aggregates assets that are ordered, delivered, and installed alongside those that are still inert. Capitalization rules defer recognition. Depreciation schedules smooth costs over time.

The result is a structural blind spot. The most consequential phase of AI infrastructure—the period where capacity is being assembled but not yet productive—barely registers in public reporting.

This is not manipulation. It is mismatch.

Accounting frameworks are optimized for stability and comparability. AI infrastructure is lumpy, nonlinear, and operationally fragile during build-out. When those realities collide, perception lags behind operational truth.

That lag is why capex debates feel unmoored. We are arguing over inputs because the outputs are not yet visible.

The Common Mistake

The blind spot leads to a persistent error.

The assumption is that rising capex implies rising AI capacity. In practice, capex buys optionality. Capacity emerges only when that optionality is executed.

Spending creates the possibility of advantage, not its realization. Utilization, resilience, and economic return arrive later—and unevenly.

This gap between possibility and performance explains much of the volatility in AI narratives. When spending accelerates, optimism follows. When utilization lags, skepticism sets in. Both reactions mistake a proxy for the thing itself.

Over long horizons, sustained investment often does translate into leadership. The error is not directional. It is temporal. Outcomes are being judged before the system has finished assembling.

Two Views of the Same Bottleneck

What looks like disagreement is usually perspective.

Operators see integration queues, validation cycles, and early clusters that are functional but fragile. Markets see capex trajectories, margin trends, and depreciation curves. Both views describe the same system, but from incompatible measurement frameworks.

Operational reality moves in bursts. Financial abstraction moves smoothly. Narratives try to reconcile the two and inevitably overshoot.

This disconnect explains why bargaining power can shift before operations do, why confidence often precedes utilization, and why skepticism frequently arrives either too early or too late.

The bottleneck is not only technical. It is epistemic.

What Will Actually Decide the Outcome

The AI infrastructure cycle will not be decided by who spends the most. It will be decided by who converts spend into uptime fastest—and who can sustain that conversion as scale increases.

Several unresolved questions matter more than headline capex totals.

Which organizations have integration throughput as a core capability rather than a temporary advantage? When do utilization metrics replace spending as the market’s anchor? Does AI demand broaden across workloads and customers, or remain concentrated among a small number of anchor tenants? And how long can accounting optics delay confrontation with operational reality?

These are tests, not predictions. The answers will emerge gradually, and not all at once.

What to Watch Next

For operators, integration throughput is not back-office hygiene. It is strategy.

For investors, capex is an input. Utilization is the outcome.

For everyone else, the confusion surrounding AI infrastructure is not a sign of disorder, but of transition. The system is moving through a phase where capacity is being built faster than it can be measured or understood from the outside.

That phase will pass. When it does, narratives will converge quickly.

The mistake is assuming it already has.

What the industry broadly labels a memory shortage is not one constraint acting uniformly across the system. It is a stacked set of bottlenecks—allocation power, platform qualification, and bandwidth physics—that bind independently and often at different moments.

When those are collapsed into a single problem, forecasts break down, mitigation strategies underperform, and downstream disruptions appear sudden when they are anything but. The issue is not scarcity alone; it is misdiagnosis.

Scarcity Is Layered, Not Singular

If memory tightness were a conventional supply problem, the system would behave predictably. Capacity additions would ease pressure, prices would normalize, lead times would shorten, and product plans would stabilize over time. That assumption underpins much of the industry’s thinking.

But it is not what we observe in practice.

Instead, outcomes diverge. Some teams ship on schedule while others are forced into late redesigns. Some platforms move cleanly through generational transitions, while others miss them entirely.

These are not the symptoms of a single constraint gradually relaxing. They reflect a layered system in which different limits bind for different participants.

In practice, three constraints dominate. Allocation determines who gets memory and when. Qualification determines which platforms that memory can actually be used on. Bandwidth determines how efficiently data can be moved once it is there.

Each can become the limiting factor on its own, and increasing capacity only helps when all three align—which they often do not.

Allocation Comes First

The first bottleneck is not technical. It is economic.

Large AI data centers do not merely consume memory; they reshape its availability. Their purchasing power, early commitments, and tolerance for platform-specific coupling effectively reallocate supply across the ecosystem.

As inference-led demand accelerates, memory flows toward buyers that can absorb risk and lock in priority well ahead of product cycles.

The downstream consequences are easy to underestimate because they rarely show up cleanly. Smaller players do not just pay more. They receive parts later, freeze designs earlier than planned, or are forced into redesigns after assumptions break.

In many cases, the cost appears not as a higher bill of materials, but as a missed launch window.

This is why memory tightness increasingly manifests as architectural disruption rather than headline pricing. Allocation pressure propagates through planning and execution long before it reaches the P&L.

Adding capacity alone does not resolve this, because allocation is about priority, not volume.

Qualification Breaks Commodity Logic

Even when memory is available in principle, another constraint often binds before it can be used: qualification.

High-end AI memory—particularly HBM—does not behave like a fungible commodity. It is tightly coupled to specific platforms, and each accelerator generation introduces narrow qualification windows that must be met precisely.

Miss the window, and that supply may as well not exist for that platform.

The result is a wave-and-reset dynamic. Supply ramps, platforms qualify, products ship, and then the generation turns. Outcomes depend less on aggregate availability than on execution across transitions.

Teams with qualification continuity move forward with relatively little friction. Teams that assume smooth handoffs discover that continuity is the exception, not the rule.

This is where linear forecasting consistently fails. It assumes gradual improvement where discontinuity is structural.

Capacity helps only if it arrives qualified, on time, and on platform. Otherwise, it simply pools elsewhere in the system.

Bandwidth Is Now the Physics Constraint

Even when memory is allocated and qualified, performance is no longer governed primarily by how much memory fits on a board. Increasingly, it is governed by how fast data can be moved.

Inference has shifted the physics. Decoder-heavy workloads stress memory not by storing large models, but by sustaining token throughput, moving KV caches, and meeting tight latency targets.

In these regimes, performance per dollar is constrained by bandwidth and data movement rather than raw capacity.

This is why inference-heavy systems often appear memory-bound even when capacity looks sufficient on paper. The constraint has migrated up the hierarchy—from storage, to interconnects, to on-package bandwidth.

Architectural responses such as pooling, tiering, and compression help, but they rarely eliminate the bottleneck. More often, they relocate it, exposing pressure at the next layer.

The Efficiency Trap

At this point, a familiar counterargument appears. If memory is tight, the system will simply become more efficient.

Smaller models, better compression, smarter caching—each reduces per-workload memory requirements, and all are real advances.

The problem is not that efficiency fails locally. It is that its system-level effects are often misunderstood.

Efficiency improves cost, latency, and usability. Those gains expand adoption, unlock new use cases, and increase overall deployment. As a result, total demand often rises faster than supply can respond.

In practice, efficiency does not reliably relieve memory pressure at the system level. In many cases, it sustains it by expanding the total addressable market.

Efficiency remains valuable, but it is not a reliable relief valve.

Why Forecasts Keep Missing

When allocation, qualification, and bandwidth are considered together, the recurring pattern becomes clearer.

Outcomes are non-linear, and transitions matter more than trends. Small differences in timing or execution produce large divergences in results. Share reshuffles occur at platform boundaries, and bottlenecks migrate rather than disappear.

Smooth curves give way to step functions.

This is also why asking how much memory will exist in 18 months consistently disappoints. More informative questions focus on structure rather than volume.

Who will control allocation during the next transition? Which platforms will qualify cleanly? Where will the bandwidth bottleneck move next?

Those variables, more than raw capacity, determine outcomes.

Fault Lines to Watch

Several uncertainties remain unresolved.

It is not yet clear which constraint will dominate across all workloads. Allocation pressure varies by market, and while bandwidth dominates inference-heavy deployments, not every system is inference-bound.

Tiering may push bottlenecks into interconnects and storage faster than expected. Or it may flatten cost curves for specific application classes.

There is also a broader strategic question still in play: whether these dynamics represent a permanent break from prior cycles or a repeatedly discontinuous one.

If qualification continuity improves, volatility may soften. If it does not, resets will remain structural.

These questions are falsifiable. That is a strength.

What to Watch Next

If memory tightness were a single problem, the fix would already be clear. It is not, which is why the system continues to surprise even experienced participants.

The most useful signals will not come from headline capacity numbers. They will come from quieter indicators: qualification continuity across generations, the evolving economics of bandwidth in inference-heavy systems, and whether efficiency gains show up as margin relief or as expanded demand.

Until those forces align, memory shortage will remain a convenient label—and a weak guide to strategy.

The real constraint is not memory in isolation, but the system that governs how it is allocated, qualified, and used.

Yet beneath the hype, one thing is consistent:

Agents are useful only when matched to the right class of problem.

Most implementation failures come from reaching for agentic architectures either where simple automation is sufficient or where autonomy simply cannot hold up. To avoid both extremes, we need a clearer framework—one grounded in capability fit rather than marketing momentum.

This essay lays out the model I use to evaluate agentic use cases and identify where autonomy truly creates leverage.

What an AI Agent Actually Is

Let’s start by restoring precision to the definition.

When I say “AI agent,” I’m not referring to any system with an LLM behind it, nor to every assistant with a chat interface. An agent is something more specific:

An AI agent is a software entity capable of perceiving its environment, making decisions, and taking action with a degree of autonomy.

The defining element is independent operation, not tool use or chain-of-thought reasoning. To clarify what this means in practice, I think in terms of six capabilities:

• Perception: Quality of environmental understanding

• Decisioning: Ability to reason and prioritize

• Actioning: Adaptiveness in execution

• Agency: Degree of self-initiated operation

• Adaptability: Capacity to adjust as conditions shift

• Knowledge: Breadth and usefulness of information applied

Most “agents” only show fragments of this list. True agents demonstrate all six at meaningful levels.

With that foundation in place, we can ask a more productive question: when is an agent the right tool for the job?

Where Agents Belong: The Middle of the Complexity Curve

Agents thrive in environments that are too variable for deterministic automation yet not so unpredictable that autonomy becomes risky or brittle. The core insight is simple:

Agents deliver value only in the middle of the complexity curve.

Imagine an inverted-U:

• Left side: The task is simple → a script or workflow engine is enough.

• Middle: The task is dynamic and context-dependent → an agent makes sense.

• Right side: The task is high-risk or unfixed → autonomy becomes unstable.

To evaluate where a use case sits on this curve, I use the same six dimensions that describe agent capabilities.

1. Complexity of the Environment

If the environment is stable and predictable, deterministic automation wins.
If it’s dynamic, multi-variable, or heavily contextual, an agent can add value.

Example:
Booking travel through a single, fixed toolchain doesn’t require autonomy. But coordinating multi-modal transportation across shifting preferences, inventories, and policies benefits from agentic flexibility.

Environmental variability is often the strongest predictor of agentic fit.

2. Complexity of the Goals

Some tasks have a single, unambiguous objective. Others require balancing tradeoffs—cost vs. speed, convenience vs. policy, personalization vs. constraints.

As soon as goals conflict, rule-based systems start breaking down.

Agents excel when the decision surface can’t be flattened into a simple rule set but doesn’t require deep human judgment either.

3. Variability of Execution

A good test: Do the steps change based on context?

• If the flow is identical every time, use deterministic automation.

• If “what happens next” depends on sensing, interpretation, or real-time conditions, agents help.

Example:
Support-ticket triage varies by customer intent, history, and metadata. Refund issuance does not.

Execution variability creates the conditions for agentic reasoning to matter.

4. Required Autonomy

Autonomy isn’t binary; it ranges from suggestion to supervision to full independence.

1. Human-in-the-loop: The agent proposes actions; humans finalize them.

2. Human-on-the-loop: The agent acts; humans review and override as needed.

3. Fully autonomous: The agent operates without intervention.

Most organizations imagine (3) but are realistically prepared for (1).
And that’s fine—use the smallest amount of autonomy that accomplishes the task.

If a use case only requires (1), a semi-agentic assistant may be more appropriate than a full agent.

5. Dynamics of the Environment

Some environments barely change. Others shift constantly due to external inputs, user behavior, or system constraints.

Agents shine when conditions evolve in ways that deterministic logic struggles to anticipate; they falter when conditions shift so unpredictably that even an adaptive system loses grounding.

Humans remain essential in settings requiring intuition, risk sensitivity, or moral judgment.

6. Breadth of the Domain

Agents gain advantage when tasks span multiple knowledge domains or require synthesizing diverse signals. Narrow domains with fixed rules are better suited to scripted logic.

Troubleshooting field equipment under uncertain conditions? Agentic.
Reconciling invoices? Not agentic.

The Sweet Spot for Agents

If a use case combines:

• context variability

• multi-goal reasoning

• dynamic inputs

• non-deterministic execution

• manageable risk

• cross-domain knowledge

…it likely falls in the agent sweet spot.

But stray too far toward either extreme—too simple or too complex—and agents either add unnecessary overhead or fail outright.

When Not to Use Agents

Despite the hype, there are several clear disqualifiers.

1. Real-Time or Safety-Critical Requirements

Agents that rely on heavyweight reasoning or multistep planning struggle with predictable latency. Industrial control, autonomous navigation, and high-frequency trading all demand deterministic behavior.

2. Mandatory Explainability

Opaque models break down in regulated or sensitive domains, including HR screening, medical triage, and compliance workflows.

When stakeholders require transparent reasoning, use causal models, rules, or structured optimization—not agentic autonomy.

3. Misaligned Cost Structure

LLM-powered agents introduce ongoing costs: tokens, tool calls, compute scaling, observability, guardrails. If the value per action is low, the economics rarely hold.

4. Tasks Requiring Human Qualities

Agents don’t replicate empathy, intuition, or nuanced judgment. In these cases, agents should augment humans, not replace them.

5. Organizational Unreadiness

Without strong data foundations, governance, monitoring, and change-management support, agentic deployments stall. Autonomy is an operational commitment, not a feature drop.

When a Single Agent Isn’t Enough: Multiagent Systems

Some problems exceed the capabilities of any one agent. Multiagent systems (MAS) become useful when:

• specialized agents outperform generalists

• redundancy improves robustness

• tasks require negotiation or distributed reasoning

• workloads exceed a single agent’s cognitive bandwidth

This is where enterprise AI is heading: ecosystems of specialized agents coordinated through explicit protocols, not monolithic “super agents.”

Examples to Ground the Framework

Strong Agentic Fit: Travel & Logistics Automation

Dynamic conditions, diverse constraints, and shifting inventories make autonomy beneficial.

Weak Fit: Safety-Critical Robotics

Latency and determinism beat flexibility every time.

Sweet Spot: Knowledge Workflows

Agents that navigate documents, tools, and reasoning outperform static RAG pipelines.

Hybrid Cloud–Edge Models

Edge agents handle perception and real-time action; cloud agents coordinate planning and refinement. This distributed pattern will define many next-generation systems.

The Coming Layer of Autonomy

Agents won’t replace every interface or every workflow. But they will become the connective layer where digital systems must navigate uncertainty, adapt to shifting conditions, and operate beyond rigid scripts.

The organizations that benefit most won’t be the ones that deploy agents everywhere—they’ll be the ones that deploy them intentionally, where autonomy compounds instead of complicates.

The real shift isn’t the rise of agentic AI.
It’s the discipline to know where autonomy creates value—and where it erodes it.

The illusion of infinite compute—the sense that intelligence scales effortlessly in the cloud—has finally cracked. Behind every “smart” model is a warehouse full of chips, turbines, and coolant lines. Behind every frontier training run is a power grid, a transformer backlog, and a construction crew trying to build a gigawatt’s worth of capacity before the next model version drops.

Sam Altman once said he wants to “create a factory that can produce a gigawatt of new AI infrastructure every week.” It’s a poetic goal, but also a reminder: the next leap in AI capability won’t come from clever code. It will come from who can industrialize intelligence fastest.

The bottleneck has moved downstream — from models to metal.

The Great Buildout

The defining story of 2025 isn’t the next GPT. It’s the trillion-dollar race to build where those GPTs can live.

NVIDIA, with a single year of profit, could theoretically fund several years of TSMC’s fab buildout. Meta has pledged over $600 billion to AI infrastructure. Oracle is pouring $18 billion into new campuses. This is not a software cycle—it’s an energy-and-materials supercycle.

We used to think of data centers as digital warehouses. Now they’re AI factories: purpose-built facilities designed to convert electricity into cognition. NVIDIA coined the term, but it’s quickly become a reality. CoreWeave’s disclosures confirm what most engineers already suspected—there’s a direct, quantifiable relationship between compute scale and model quality. The more power you can marshal, the smarter your systems become.

And the numbers are staggering. A single Rubin Ultra Rack can draw nearly 600 kW, dwarfing traditional setups. Power and cooling are no longer infrastructure details—they’re the boundaries of innovation itself.

Compute capacity has become the new form of capital.

Energy Becomes the New Constraint

Every generation of computing has had a limiting reagent. For AI, it’s electricity.

Compute demand is outpacing the grid. Datacenters that once scavenged industrial leftovers—abandoned aluminum plants, defunct auto factories—now find themselves competing for raw generation capacity. Power availability has replaced silicon as the true gating factor for scale.

The trade-offs are brutally real:

• Natural gas: quick to deploy, dirty, and politically fraught—but the only option that meets short timelines.

• Nuclear: clean with low operating costs, yet bound by decade-long permitting cycles.

• Solar: cheap in theory, but requires 4–7× overcapacity plus batteries to run 24/7. The world’s largest solar farm covers seven Manhattans to sustain just 3 GW of smoothed output.

Across the world, governments and utilities are scrambling to reconcile these pressures. The constraint is no longer technological—it’s infrastructural. Whoever learns to generate, distribute, and balance massive, continuous loads of power will shape the next decade of AI.

Every AI model is ultimately an energy story.

The Global Compute Divide

This is the new arms race—not for algorithms or data, but for energy and industrial throughput.

America still leads in chip design, model research, and capital velocity. But China is winning the long game of infrastructure scale. While U.S. hyperscalers fight grid delays and permitting backlogs, China continues to add power generation, transmission, and manufacturing capacity at an industrial pace. Its vertically integrated energy-to-compute pipeline—from solar fabrication to transformer production—lets it build datacenter power faster and cheaper than any rival. For every GPU cluster in the West, China is building the power plants that could host ten more.

The asymmetry is temporal as much as technical.
The U.S. runs on three-year depreciation cycles and quarterly CapEx reports.
China runs on decades.

If AI remains hardware-intensive, the winner may simply be whoever can sustain industrial expansion longest. The irony? Export controls might slow China’s chip supply today, but not forever. If the intelligence race turns physical—fueled by solar, steel, and labor—the balance of power could tilt eastward by 2030.

The Economics of Overbuild

Is all this spending sustainable? Maybe not—but that’s not the right question.

History shows that overbuilds often lay the groundwork for future revolutions. The dot-com bubble left us a global fiber network. The crypto boom built modular datacenter supply chains. Even if the AI bubble bursts, what remains is an industrial base capable of producing compute and power at unprecedented speed.

GPUs will depreciate in three years. The power plants and cooling systems will last decades. The enduring value might not be the models, but the manufacturing muscle we build along the way—the ability to turn capital into cognition on demand.

Some call it an AI bubble. I’d call it infrastructure compounding.

Even if the bubble bursts, the factories stay.

The Hidden Crisis and How Winners Will Build Differently

Cisco’s 2025 AI Readiness Index surveyed more than 8,000 executives across 30 markets. The result was sobering:

• 83 % of companies plan to deploy AI agents.

• Only 13 % have the infrastructure to support them.

The rest are about to learn a costly lesson about the gap between ambition and capability. Cisco calls it AI infrastructure debt—the accumulation of shortcuts and compromises that come from rushing to deploy AI on systems never designed for it. It’s what happens when GPU scarcity meets legacy networks and “we’ll-fix-it-later” architectures.

Among those surveyed:

• Only 26 % have adequate GPU capacity.

• 31 % feel prepared to secure autonomous AI agents.

• 85 % admit their networks can’t handle AI workloads at scale.

The “Pacesetters”—that top 13 %—show what readiness looks like. They deploy at ten times the speed, measure impact rigorously, and report 1.5× higher profitability.

Readiness is no longer about compute alone—it’s about placement.
Winners design for intent, not imitation. They split workloads between edge AI and cloud AI, aligning each with its natural strengths.

The companies I’ve seen that are effectively using AI to uplevel their operations all take this approach, using the cloud to learn and the edge to act. Their architectures behave more like organisms than systems—reflexive at the edges, thoughtful at the core.

So what separates the few who thrive from the rest who stall?
They build differently.

1. Treat infrastructure as product strategy. Decide early what runs local versus remote—it defines latency, cost, and trust.

2. Design for modularity. Edge and cloud systems evolve independently but connect seamlessly.

3. Automate lifecycle management. Synchronizing models across tiers is a living process, not a deployment step.

4. Secure from the ground up. Each node expands your attack surface; resilience must be systemic.

This is the playbook for the industrial age of AI. The winners aren’t just scaling models—they’re distributing intelligence where it creates the most value.

The Industrialization of Intelligence

AI’s next leap won’t look like another app launch. It’ll look like a skyline.

Steel, concrete, and high-voltage substations—the material artifacts of intelligence—are spreading across Texas, Arizona, and Inner Mongolia. Each facility is a bet that our hunger for computation will outlast any model hype cycle. And even if the frenzy cools, the grid we build to feed it will remain—like the railways of a previous revolution.

We used to ask whether a product had market fit.
Now we ask whether an idea has the infrastructure to exist.

The smartest model in the world is useless if you can’t keep the lights on.

The next wave of AI isn’t about access to intelligence anymore. It’s about what happens when intelligence itself becomes fast, cheap, and everywhere—and when progress stops being smooth.

Three ideas capture this shift:

1. Intelligence becomes a commodity

2. Verifier’s Law: Measurement drives progress

3. The jagged edge of intelligence: Some domains leap forward, others lag

Intelligence Becomes a Commodity

Every new AI capability follows a familiar pattern.

• Stage 1: Frontier pushing. Researchers unlock a new ability—solving competition math problems, reasoning across documents, composing music.

• Stage 2: Commoditization. Once that ability exists, the cost to access it falls toward zero.

That second stage is now accelerating. Models like OpenAI’s o1 introduced adaptive compute—spending more computation on hard problems and less on easy ones. Instead of brute-forcing every query equally, intelligence flexes like a muscle: efficient on simple tasks, deliberate on complex ones.

The result is profound. The cost per solved problem is collapsing even without larger models, reshaping what it means to “own” intelligence.

The Collapse of Time-to-Knowledge

Knowledge has entered an age of compression.

Before the internet, finding a niche fact meant hours of searching through books.

The internet reduced that to minutes.
Chatbots cut it to seconds.

And now, agentic systems that can browse, click, and query databases are collapsing that final layer of friction—delivering contextual answers almost instantly.

Benchmarks like BrowseComp capture this shift in quantitative form. They measure tasks that might take humans hours to research but only seconds to verify once the answer is found. Agentic systems can already complete a significant share of them autonomously.

What was once search is becoming verification: knowing not just where to look, but how to confirm correctness at machine speed.

This is where AI progress is heading—time-to-knowledge approaching zero.
The value chain is shifting from retrieval to reasoning, and from discovery to validation.

In a world where finding information costs almost nothing, the true differentiator becomes how precisely and confidently you can trust it.

The New Scarcity

As intelligence becomes abundant, information stops being the bottleneck. What matters now is:

• Context — knowing which question to ask

• Data — owning signals that aren’t publicly available

• Trust — verifying that what’s generated is correct

In other words: public knowledge is free; private knowledge is priceless.

That shift explains why startups are embedding LLMs into proprietary data stacks, and why even small teams are building “personalized internets”—systems that reason over private, contextual information instead of generic web results.

The cloud made compute abundant. Agents will make intelligence abundant. What remains scarce is meaning.

The world’s next competitive edge won’t come from knowing more, but from knowing what matters.

Verifier’s Law — Measurement Drives Progress

Here’s the simple rule shaping AI’s trajectory:

The rate of AI progress on a task is proportional to how easily that task can be verified.

This principle explains why AI outperforms humans in coding, Sudoku, and math, yet still hallucinates in essays or medical advice. Code and math have clear verifiers—there’s a right answer, a quick test, and a feedback loop that runs at machine speed.

When verification is strong, progress compounds. When it’s weak, models stall.

The Asymmetry of Creation vs. Verification

Some tasks are hard to create but easy to check.

• Writing a working function or proving a theorem takes skill, but correctness is binary.

Others are easy to create but hard to check.

• Writing an essay or designing a logo is fast, but quality is subjective.

AI devours the first type and struggles with the second. Systems like DeepMind’s AlphaEvolve illustrate why: they generate thousands of candidates, score each precisely, feed back the best, and iterate. When the metric is solid, performance climbs rapidly. When it’s noisy, progress flattens.

Verification as the Next Frontier

Most AI breakthroughs happen in domains with tight feedback loops—translation (BLEU), classification (accuracy), retrieval (F1), or coding (unit tests). But that also means entire industries are stuck because their metrics are fuzzy or inconsistent.

If you can invent a reliable metric, you can accelerate progress.

That’s why a new role is emerging: the verifier engineer—designing grading systems, evaluators, and reward models that close the loop between generation and truth.

AI doesn’t improve where it can’t measure itself. Verification is the real accelerator.

In a world of cheap intelligence, measurement becomes leverage. Whoever defines the metric defines the market.

The Jagged Edge of Intelligence

For all the talk of “fast takeoff,” AI’s progress isn’t smooth—it’s jagged.

Some capabilities, like program synthesis or image generation, leap forward. Others—common sense, causal reasoning—barely move. There’s no single progress curve, only a serrated edge advancing unevenly across domains.

Why the Edge Is Jagged

AI’s rate of improvement depends on three things: digitization, measurement, and data.

Digital, data-rich, and objective tasks improve fastest because feedback loops are clear and compute scales easily.

Embodied or subjective tasks lag because data is messy, costly, or hard to label.

This divergence creates AI inequality—a widening gap between digital domains that accelerate exponentially and physical or social ones that remain largely human.

Forecasting the Next Wave

To forecast where AI will move next, ask three questions:

1. Is the task digital? (Can it be simulated?)

2. Is it measurable? (Is there a clear definition of success?)

3. Is it data-rich? (Can it iterate quickly?)

If all three are true, automation will move fast. If not, progress will slow—until someone invents a better verifier.

The shape of progress isn’t a curve—it’s a coastline, advancing where measurement is strongest.

Understanding that contour helps predict where disruption lands first.

Intelligence as Infrastructure

This all leads to a larger realization: intelligence is becoming infrastructure. Like electricity or bandwidth, it’s becoming cheap, ubiquitous, and quietly essential.

But infrastructure spreads unevenly. Electricity reached cities long before rural areas; broadband reached white-collar work before factories. AI will follow the same path: digital and measurable domains light up first, while embodied or contextual work takes years to catch up.

That’s not failure—it’s structure. Progress has always arrived in waves, not walls.

Closing Thoughts

As intelligence becomes free, advantage shifts from those who possess it to those who can measure it.

The next decade of AI won’t belong to whoever builds the biggest model—it’ll belong to whoever builds the best verifier.

Because once you can measure progress, you can automate it.
And once you can automate it, the cost of intelligence falls to zero.

Yet somewhere between soaring API bills, data-residency headaches, and tightening compliance rules, that logic began to crack. More enterprises are quietly pulling workloads back in-house. IDC reports that most now repatriate at least part of their AI stack each year. The reason isn’t nostalgia, it’s necessity.

Cloud made AI accessible. On-prem is making it accountable.

From Model to Machine: The Agentic Shift

The last generation of AI systems answered questions; the next generation takes action.

Agentic AI represents that evolution—models that can plan, reason, and execute autonomously. These systems don’t simply respond to prompts; they operate within workflows, drafting reports, monitoring pipelines, triggering alerts, and making real decisions with minimal human oversight.

That change—from inference to execution—exposes the limits of cloud-based architecture. Agents depend on continuous context from internal systems, ultra-low latency for real-time decisions, and persistent memory that respects corporate boundaries. When they process sensitive data—financial records, medical scans, or network telemetry—sending information to external servers becomes unacceptable.

Agentic AI and on-prem infrastructure are converging because autonomy demands proximity and control. When your AI holds the keys to your business, you don’t want it living in someone else’s house.

The Case for On-Premises Intelligence

On-prem AI isn’t a regression; it’s a return to sovereignty. It gives organizations complete authority over where their intelligence resides, how it behaves, and who has access to it.

By deploying agentic systems locally, companies gain more than privacy—they gain predictability. Data never leaves internal boundaries, aligning naturally with regulations such as HIPAA, GDPR, RBI, and DPDP. Inference happens beside the data itself, eliminating the lag that comes from remote processing. Costs stabilize because performance isn’t metered per call, and integrations become simpler when agents can communicate directly with enterprise systems like ERP or CRM.

Consider a regional bank that runs an on-prem agent to monitor transactions in real time. When the system detects anomalies, it can freeze accounts, generate compliance reports, and update logs—all within its private network. No external APIs, no latency, no exposure.

The result isn’t just greater security—it’s operational clarity.

Smaller Models, Bigger Impact

For years, the industry assumed that progress in AI meant building ever larger models. Then NVIDIA’s research paper, “Small Language Models Are the Future of Agentic AI,” challenged that assumption.

It confirmed what edge engineers already suspected: most agentic workloads don’t need massive, multi-billion-parameter systems. Small Language Models (SLMs) can handle a majority of enterprise tasks while running efficiently on a single GPU or even a CPU. They deliver sub-second latency, fine-tune easily on domain-specific data, and operate with far less overhead.

In tests across frameworks like MetaGPT, Open Operator, and Cradle, NVIDIA found that 40–70% of large-model calls could be replaced by smaller ones without loss in performance.

Use the right-sized brain for the right-sized problem.

The same principle that made microservices scalable applies here: specialization beats generalization. You don’t need a 70B-parameter model to summarize reports or flag anomalies—you need a focused, fine-tuned SLM running securely where your data already lives.

Building the On-Prem Agentic Stack

Bringing AI home isn’t about abandoning the cloud—it’s about gaining control and proximity. A modern on-prem stack blends three layers:

1. Hardware: local GPU clusters or accelerators with high-speed storage and networking.

2. Software: secure model repositories, orchestration tools, and APIs that connect agents to enterprise systems.

3. Governance: access controls, performance dashboards, and audit logs that keep operations transparent.

In practice, it’s simple: local inference → local reasoning → local action. The cloud still plays a role in retraining or analytics, but the core intelligence now runs inside your own walls.

The goal isn’t isolation—it’s sovereignty with flexibility.

Where It’s Already Happening

This shift isn’t theoretical—it’s happening across industries where real-time decisions and data control are non-negotiable.

In manufacturing, agents analyze factory sensor data to predict equipment failures before they occur, reducing downtime and maintenance costs.

In healthcare, hospitals process imaging data like X-rays or CT scans locally, keeping patient records private while accelerating diagnosis.

In telecom, agentic systems predict network outages and automatically reroute bandwidth to maintain service continuity.

In energy and utilities, distributed agents balance grid loads across substations—even in disconnected or air-gapped environments.

Different industries, but the same logic: speed, sovereignty, and reliability have become the new competitive edge.

Why “Hybrid” Isn’t the Compromise You Think

Hybrid architectures—part cloud, part on-prem—promise flexibility but often deliver friction. Splitting workloads across environments introduces synchronization delays, fragmented data contexts, and dual governance complexity.

Agentic systems thrive on unified context: every decision, every action, rooted in a single, consistent environment. When that continuity breaks, performance and compliance erode together. For organizations dealing with sensitive data or mission-critical operations, half-local quickly becomes half-secure.

Agentic AI works best when its world is whole.

The Economics of Bringing AI Home

At first, the cloud looks cheaper: no upfront costs, instant scalability, and no hardware to manage. But once AI becomes central to business operations, the economics shift dramatically.

Cloud deployments depend on per-token billing, unpredictable usage spikes, and vendor lock-in. On-prem solutions, while more expensive to set up, offer stable, predictable costs over time. Compute resources are fully utilized, latency is lower, and performance doesn’t degrade under load. Combined with small-model efficiency and hardware amortization, on-prem often becomes more cost-effective within a few quarters of deployment.

In AI, control isn’t just power—it’s ROI.

The Future: Distributed, Local, and Agentic

The pendulum is swinging back toward local intelligence—not because the cloud failed, but because data, context, and decisions belong together.

Tomorrow’s enterprises will run networks of small, specialized agents that operate locally, collaborate securely, and share insights only when needed. This model of federated autonomy—many focused models instead of one massive one—will define the next phase of AI.

The cloud will still matter, but as a coordination layer, not the core. The real thinking and acting will happen close to the data—at the edge, not in the ether.

The world’s largest tech firms are renting out Nvidia GPUs at breakneck speed—and barely profiting.

Oracle, now a self-styled AI cloud leader, earns about fourteen cents for every dollar of GPU rentals. AWS and Google Cloud face similar pressure. The infrastructure driving this “AI revolution” runs on shrinking margins and rising depreciation.

In a market built on exponential scale, very few are capturing value.

The Value Chain in Motion

The AI stack has collapsed inward. Chipmakers are moving up the chain; model developers are moving down. Cloud providers are caught in the middle.

Upstream, Nvidia reigns. It doesn’t just sell GPUs—it sells an ecosystem: CUDA, networking, developer tools. Each reinforces the other, keeping its operating margins around 70%.

AMD plays the open alternative. Its partnership with OpenAI—supplying up to 6 gigawatts of Instinct GPUs plus a warrant giving OpenAI the right to buy 10% of AMD for one cent per share—aligns incentives. AMD gets a guaranteed buyer; OpenAI gets capacity and upside.

Broadcom, meanwhile, is becoming the quiet contractor of AI hardware—designing custom chips that encode model logic directly into silicon.

Midstream, the hyperscalers are squeezed. Their core business depends on Nvidia hardware whose costs they can’t control. AWS is countering with Trainium, its in-house AI chip now powering most Bedrock workloads. It’s slower than Nvidia’s top GPUs but cheaper—and that’s what matters when profitability depends on utilization, not peak performance.

Downstream, AI developers are rewriting the rules. OpenAI and Anthropic aren’t just cloud tenants anymore. They’re becoming infrastructure investors, equity partners, and chip designers. The line between buyer and supplier has vanished.

The Margin Chain

Every revolution hides a spreadsheet.

Oracle’s GPU business: $900 million in revenue, $125 million in gross profit—14% margins before depreciation. The culprit is utilization. AI hardware ages quickly; every new Nvidia release devalues the last. Oracle’s data centers run between 60% and 90% capacity, which means expensive GPUs sitting idle.

Key takeaway: the AI infrastructure economy is capital-intensive, not capital-efficient.

Nvidia alone escapes the gravity. Its hardware, software, and networking stack create self-reinforcing lock-in: more developers on CUDA, more optimization for CUDA, and no realistic alternative. While clouds fight for pennies, Nvidia earns dollars.

The Neocloud Play

The neoclouds—Together AI, CoreWeave, Lambda—are the industry’s margin experiment.

Rather than chase scale, they chase utilization. Together AI runs near full capacity by serving AI startups training or fine-tuning models, growing to a $300 million run rate with roughly 45% margins. Owning GPUs gives it control—but also exposure to obsolescence and capital costs.

Nvidia quietly finances these firms because they weaken the hyperscalers’ grip. Each neocloud increases competition for AWS and Azure while guaranteeing Nvidia full utilization.

Example: Together’s expansion into Saudi-backed data centers shows how geopolitics now intersects with AI supply. Compute has become a strategic export.

Integration as Strategy

AI has inverted the cloud’s founding promise of “scale without hardware.” Now, owning the hardware—or the economics behind it—is the only way to stay profitable.

OpenAI’s AMD deal isn’t just a chip order; it’s vertical integration through equity. By locking in supply and future ownership upside, OpenAI turns a cost center into a balance-sheet asset.

AWS does it differently. Trainium lets it swap Nvidia’s volatility for internal control. Bedrock customers never choose the chip powering their API call, giving AWS quiet leverage to optimize for margin rather than raw power.

Oracle, by contrast, leases both its data centers and its GPUs and relies heavily on OpenAI’s contracts. Its revenues may be soaring, but its negotiating power is shrinking.

Key takeaway: The new advantage isn’t scale—it’s integration. The winners absorb the most margin-dilutive layer of their own value chain.

Where the Power Actually Lives

Follow the money and you get an hourglass:

• At the top, model providers like OpenAI and Anthropic control demand.

• At the bottom, Nvidia controls supply.

• In the middle, cloud providers and neoclouds compress their own margins to connect the two.

The real contest is over control, not capacity. Nvidia controls the software standards. AWS controls workload routing. OpenAI controls its own supply chain through financial leverage.

Everyone else fights for position in the narrow middle—essential, but structurally trapped. Their inputs scale linearly; their profits don’t.

Key takeaway: In AI, value accrues to those who manage dependency, not volume.

The Economics of Constraint

AI demand is theoretically infinite. Capital isn’t.

Each breakthrough increases consumption faster than efficiency gains can offset it. Sam Altman calls it the “10× → 20×” rule: every tenfold improvement in capability drives twentyfold higher usage. The result is an industry addicted to its own cost curve.

This forces every major player to become part financier, part manufacturer. Nvidia invests in neoclouds; AWS designs chips; OpenAI buys into AMD. Each is translating capex into leverage.

Key takeaway: The strongest differentiator isn’t access to GPUs—it’s the ability to finance them without eroding margins.

The New Map of AI Power

A new industrial hierarchy is forming:

• Nvidia profits from selling scarcity.

• AWS and Google profit from utilization.

• OpenAI and Anthropic profit from turning compute into product revenue.

• Oracle and the neoclouds absorb volatility for everyone else.

Every contract in this ecosystem is a negotiation over who bears the depreciation risk. When Oracle underprices GPU rentals to keep OpenAI’s business, it’s trading future margin for short-term growth. When OpenAI invests in AMD, it’s buying a hedge against its own input costs.

Key takeaway: AI’s power structure is defined less by model performance and more by financial engineering.

Value Flows, Not FLOPs

Nvidia doesn’t just sell chips—it monetizes every watt that passes through them.
AWS doesn’t just host workloads—it arbitrages its own supply chain.
OpenAI doesn’t just train models—it converts supplier relationships into equity.

The rest of the ecosystem—clouds, resellers, and neoclouds—remains caught between suppliers who charge more and customers who expect less. Their challenge isn’t scaling compute; it’s surviving its economics.

In the end, AI’s value chain isn’t about who owns the most GPUs, but who manages their depreciation the best.

Final takeaway: The real power in AI isn’t measured in flops or gigawatts—it’s measured in who gets paid when the chips start aging.

When OpenAI announced its $6.5 billion acquisition of Jony Ive’s secretive hardware startup, I/O, it seemed like a design story.

The goal: to ship 100 million “AI companions”—screen-free, voice-aware devices that might one day replace the iPhone.

But the deeper meaning wasn’t aesthetic—it was geopolitical.

This was a declaration of war against Apple’s dominance, and a signal that OpenAI doesn’t just want to power the apps of the AI era. It wants to own the platform itself.

Yet the real story isn’t about Ive, Altman, or Apple. It’s about where value is actually being captured in the new AI economy.

For all the noise about model benchmarks and chat interfaces, power in AI isn’t where most people are looking.

Behind every AI breakthrough lies a network of industrial bottlenecks—megawatts, chip fabs, data rights, and distribution pipelines—that determine who survives and who fades.

This is the quiet war unfolding beneath the hype.

The Foundations of Intelligence

“Intelligence consumes power—a lot of it.”

That single statement captures the first truth of the new era: AI is limited not by creativity, but by physics.

OpenAI’s Stargate data center in Texas—reportedly costing up to $500 billion—will require its own power plant just to operate.

Bank of America now projects global AI capital expenditures will hit $432 billion next year. These aren’t software numbers. They’re industrial ones.

The New Landlords

Hyperscalers like Amazon, Microsoft, and Oracle are in a global land grab—not for users, but for land and power.

Whoever builds fastest wins. Construction speed has become a competitive advantage; each delay costs millions in foregone compute.

Even Bitcoin miners—long dismissed as speculative—have become unexpected suppliers. Their data centers, cooling systems, and long-term power contracts make them early owners of the new commodity: megawatts. CoreWeave, a former crypto miner turned AI cloud provider, is now a key node in OpenAI’s supply chain.

The Physics of Scarcity

The International Energy Agency projects that data centers could consume as much electricity as Japan by 2030.

Power has become the number-one constraint—ahead of chips or land. Every hyperscaler is now an energy company in disguise, quietly striking nuclear and natural gas deals to secure long-term supply.

In this world, the language of strategy has shifted from features and functions to gigawatts and cooling capacity.

Nvidia’s Empire of Silicon

At the center of it all sits Nvidia. The company now controls 92% of the AI data center market, and its moat isn’t just faster chips—it’s the entire ecosystem around them.

CUDA has become the lingua franca of AI research. NVLink connects thousands of GPUs into a single distributed brain. Nvidia’s vertical integration—from networking to software—forms a fortress that’s nearly impossible to replicate.

The result is what insiders call the Nvidia tax: 80% gross margins on chips, gladly paid by hyperscalers racing to stay competitive. Jensen Huang often describes AI economics in terms of “revenue per megawatt.” Whoever controls the ratio of energy to compute now controls the economy.

Every $1 of AI software revenue depends on roughly $100 of infrastructure investment.

The foundations of this industry are literal: steel, silicon, and power.

The Fuel: Data as the New Legal Commodity

“Compute is the engine; data is the fuel.”

For years, AI labs treated the open web as a free buffet—scraping trillions of words and images from blogs, forums, and news sites. That era is over.

The lawsuits reshaping data ownership—led by The New York Times v. OpenAI/Microsoft—will determine who truly owns the raw material of machine intelligence.

The Rise of Data Refineries

Companies like Scale AI now sit at the center of the AI supply chain, performing the unglamorous work of cleaning, labeling, and structuring data. Their value is logistical, not algorithmic—and that’s precisely what makes it defensible.

Meta’s $14.3 billion investment for a 49% stake in Scale AI signals the shift: control the refinery, and you control the flow.

Synthetic Data and Collapse Risk

As legal and financial barriers to human data grow, labs are turning inward—training models on their own outputs to manufacture synthetic datasets. It’s a clever workaround with a dark side.

When AI learns from itself, quality degrades. Researchers call this model collapse: a kind of digital inbreeding that produces more confident but less accurate systems.

The data war is no longer about quantity—it’s about legitimacy. The companies that secure exclusive, high-quality, and lawful data pipelines will fuel every layer above them.

The Fragile Middle: Models and Interfaces

The public face of AI—the models and the devices they inhabit—sits atop this industrial scaffolding, but it’s also the most unstable part of the stack.

The Model Arms Race

The talent market has become absurd: seven-figure signing bonuses, $100 million retention packages, and a few hundred elite researchers courted personally by CEOs.

Yet all that capital buys less differentiation every quarter. The “DeepSeek moment” in early 2025—when a small Chinese startup achieved frontier-level results on older chips—proved that breakthroughs are no longer gated by hardware budgets.

OpenAI, Anthropic, DeepMind, and xAI are now trapped on a treadmill of incremental releases (GPT-4.1, Gemini 2.5, Claude 3.5), each one quickly matched by rivals. The moat isn’t intelligence—it’s iteration speed.

The Interface Wars

Meanwhile, the front door to AI—the user interface—is undergoing its own transformation. Apple still dominates distribution with two billion active devices but is playing defense, outsourcing AI capability to OpenAI.

Meta’s Ray-Ban glasses, Google’s multimodal AI mode, and Perplexity’s Comet browser all challenge the notion that AI must live inside a phone or search box. Comet, backed by Jeff Bezos and Nvidia, reimagines the browser as an agentic operating system—a space where the web doesn’t just answer, but acts.

Owning the interface means owning the default—and in an AI world, the default is destiny.

From Potential to Profit: The Boomtown Layer

For all the hype around frontier models, the real money is flowing into the application layer—the companies quietly wiring AI into everyday business systems.

Salesforce’s $8 billion acquisition of Informatica was about data pipelines, not demos. Adobe’s Firefly and Sensei tools continue to lift revenue.

Accounting firm RSM reports 80% efficiency gains from autonomous compliance agents. Startups like Mechanis are building “robotic employees” that execute tasks end-to-end.

This is the boring but lucrative part of the AI economy: where intelligence becomes infrastructure.

The Age of Agentic Commerce

OpenAI’s latest DevDay unveiled its next big play—turning ChatGPT into an operating system for digital transactions.

Apps like Spotify, Uber, and Canva can now be called directly inside ChatGPT. Instant Checkout integrates Shopify, Stripe, and Etsy, letting users complete purchases without leaving the chat.

This isn’t about subscriptions anymore—it’s about transaction flow. ChatGPT becomes a super-aggregator, controlling both the conversation and the commerce that follows.

In Ben Thompson’s framing, OpenAI is trying to become the Windows of AI: the layer every user touches, and every developer must build for.

The Productive Bubble

Every technology revolution rides a bubble. The railroad bubble left tracks. The dot-com bubble left fiber. The AI bubble will leave power.

Even if many current players vanish, the infrastructure they’re funding—data centers, grids, and new energy capacity—will endure. That’s what makes this a productive bubble, not a destructive one.

As Ben Bajarin notes, the companies sitting on land and power “basically have gold mines.” AI demand will drive innovation in energy—especially in nuclear micro-reactors and natural-gas projects—over the next decade.

The industry’s biggest externality may also become its greatest legacy: a rebuilt electrical backbone for the digital world.

Industrial Strategy Returns

What’s emerging looks less like Silicon Valley and more like a 21st-century industrial economy.

• Oracle has become the “TSMC of data centers,” a neutral infrastructure provider for anyone who can pay.

• Intel is being revived as a national insurance policy—too critical to fail, too slow to survive without help.

• AMD’s partnership with OpenAI echoes the old IBM–Intel–AMD triad of the PC era, creating a second-source strategy reminiscent of the early Windows ecosystem.

• Nvidia, meanwhile, is quietly financing its customers—distributing GPUs and guarantees the way an empire distributes currency.

The parallels to history are striking. Just as Microsoft became indispensable to the PC economy, OpenAI is positioning itself as the linchpin of the AI buildout—organizing, intentionally or not, the ecosystem around its platform. And just as IBM needed AMD to keep Intel honest, OpenAI needs AMD (and possibly Intel) to keep Nvidia’s margins from swallowing the stack.

Where Real Power Lies

The glamour of AI hides a simple truth: power is consolidating at the bottom and the top of the value chain.

Everyone else is renting space in between.

Real strategic leverage comes from controlling what AI runs on, or where its value lands.

Everything in the middle—models, assistants, and APIs—is a bridge, not a fortress.

The Framework for Durable Power

A simple lens for separating signal from noise:

1. Infrastructure: Does this increase or reduce dependency on a single compute or energy provider?

2. Data: Does it generate proprietary data or recycle the commons?

3. Model: Is it a real performance leap or just an incremental benchmark?

4. Interface: Does it reinforce existing platforms or create a new one?

5. Application: Does it make someone money right now?

Ask these questions, and the power structure of any AI announcement becomes clear.

The New Industrial Order

The AI war is no longer defined by algorithms—it’s defined by infrastructure.

At the bottom of the stack, control over compute, power, and data pipelines determines the pace and scale of progress.

At the top, applications and agentic systems decide where value is ultimately realized.

The middle layers—models and interfaces—remain volatile, dependent on external suppliers and distribution channels.

Power sits at the bottom of the stack. Profit sits at the top.

Long-term advantage will accrue to:

• Infrastructure owners optimizing the energy-to-compute ratio.

• Application builders converting AI capability into measurable productivity or commerce.

Everyone else operates on rented ground.

In short: The future of AI will be shaped less by breakthroughs in intelligence and more by the efficiency of the systems that support it.

Real power lies in controlling the flow—from electrons to enterprise outcomes.

We’re entering an era where video is no longer filmed or produced in the traditional sense. It’s generated, remixed, and infinitely iterated—faster than attention spans can keep up.

The GPT-4 Moment for Video

The leap from Sora 1 to Sora 2 is as stark as the jump from GPT-1 to GPT-4. Gone are the fever-dream physics and glitchy morphs. In their place: realistic motion, synchronized audio, even accurate failure modeling. Ask Sora to show a skateboarder botching a kickflip, and it won’t “cheat” by teleporting the board back under their feet. The physics engine now lets the fall play out with believable gravity.

Then there’s Cameo. Record your face and voice once, and the system can insert you—or your dog, or your best friend—into any generated scene. You become a co-author of your likeness. You decide who can use it, revoke access at any time, and even remove yourself from videos after the fact. Sam Altman calls Sora “the most powerful imagination engine ever built.” He’s not exaggerating.

But just as important as the model itself is the decision to launch a standalone Sora app. Unlike TikTok or Instagram, where AI clips would blend invisibly with human content, Sora is an ecosystem of only AI-generated video.

That separation matters: it preserves trust, shields the creator economy, and lets OpenAI build moderation guardrails at the point of creation. It’s a product choice with deep philosophical stakes.

The Platform Gold Rush

OpenAI isn’t alone. Every major platform is sprinting toward AI-first video.

• Meta’s Vibes feed is a nonstop scroll of AI-generated clips, designed for remixing. The Verge called it “an infinite slop machine”—eye candy without story, novelty without substance.

• YouTube Shorts will soon integrate Google’s Veo model. For now, it’s limited to green-screen backgrounds, but full six-second generated clips arrive next year.

• TikTok barely needed to announce anything. It’s already flooded with uncanny, often surreal AI creations: pets doing choreographed motorcycle dances, “shrimp Jesus” sightings, fake vampire arrests by the U.S. government.

Each platform has a different angle, but the logic is the same: AI video keeps feeds full, engagement steady, and ad impressions flowing.

When Video Becomes Slop

If you’ve spent time on TikTok or Meta’s new feeds, you’ve probably seen what critics now call AI slop. These are uncanny, repetitive clips—cheaply generated, instantly forgettable, and endlessly produced.

Why does it spread? Platforms optimize for quantity over quality. A single creator can pump out dozens of clips per day at near-zero cost. An entire “AI side-hustle” economy has emerged around this, complete with courses, prompt packs, and tutorials promising passive income. One TikTok entrepreneur reportedly made $5,500 in a single month by mass-posting AI clips across multiple accounts.

The paradox is obvious: content is effectively infinite, but human attention is not. Slop thrives in this imbalance. It’s cheap, disposable, and perfectly suited to algorithms that reward novelty over meaning.

The Fault Lines

This isn’t just about silly pet videos. AI video is surfacing a set of deep risks:

• Misinformation: Deepfake-style videos of public figures are only a few prompt restrictions away.

• Copyright: OpenAI’s opt-out policy for training data flips the burden onto creators, forcing them to track down whether their work has been scraped. Opt-in would be the ethical choice, but it’s less convenient for model builders.

• Economics: Human creators can’t compete with near-zero marginal cost. Without separation, AI could easily swamp existing creator economies.

• Psychology: Like junk food, slop satisfies in the moment but erodes engagement over time. Novelty without narrative leaves audiences burned out.

Each of these fault lines points to the same tension: AI video is immensely powerful, but misaligned incentives risk turning it into a flood of meaningless filler.

Two Possible Futures

From here, the trajectory could fork.

In one future, AI becomes a true imagination engine. Tools like Sora unlock new forms of creative expression—friends starring in their own Hollywood-grade skits, creators remixing visual ideas as fluidly as memes. Storytelling becomes more participatory, more playful, more human.

In the other, AI devolves into slop machines. Feeds optimized for engagement drown users in disposable content. Storytelling gets replaced by spectacle. Platforms become infinite loops of empty calories.

Which future wins depends less on model capability and more on design choices: moderation policies, platform separation, economic incentives, and cultural norms.

The Attention Wars

AI video isn’t going away. It’s about to become the default format for how we consume, communicate, and play online. The real question isn’t what these models can generate—it’s what do we want to watch?

The early internet taught AI how to read and write. Social media taught it how to speak our language. Now, shortform video is teaching AI how to entertain—and distract—us at scale.

The battle isn’t over realism. It’s over attention, and whether imagination engines can coexist with the slop machines they inevitably enable.

It’s memory.

Every AI agent—no matter how powerful the underlying model—lives and dies by what fits into its context window. Plans, tool calls, errors, and observations all compete for the same limited space.

• Fill it badly, and the agent slows down, drifts off course, or collapses under its own weight.

• Shape it well, and the same model suddenly looks sharper, faster, and more reliable.

This discipline has a name: context engineering.

If the model is the CPU, context is RAM. And just as operating systems revolutionized computing by managing memory, context engineering is emerging as the operating system for AI agents.

It’s not about clever prompts anymore. It’s about designing how information flows, persists, and gets reused inside the loop.

Why Context Matters More for Agents Than for Chatbots

Chatbots live in a balanced world: you send a prompt, they return an answer. Input and output stay roughly proportional.

Agents operate differently.

In Manus, one of the most ambitious agent systems built to date, the average ratio of input to output tokens is about 100:1. Each action taken and each observation received is appended to context.

What grows is the log of state. What shrinks is the output—often a short structured function call.

This imbalance has real consequences:

• Poorly engineered context drives latency, inflates costs, and produces brittle behavior.

• Well-engineered context keeps agents fast, grounded, and reliable.

It’s the difference between an agent that drifts after ten steps and one that runs through fifty without breaking stride.

The Craft: How Engineers Shape Context

Look closely at production agents and you’ll see recurring patterns—practices that tame sprawling traces into stable loops.

1. Optimize the loop.

KV-cache hit rate is the single most important performance metric.

• Keep system prompts stable.

• Use deterministic serialization.

• Append logs instead of modifying them.

These basics can mean the difference between paying three dollars per million tokens and thirty cents. Even small details—like including a timestamp in the system prompt—can wipe out cache efficiency.

2. Control the action space.

As agents accumulate tools, it’s tempting to dynamically load or unload them. That usually backfires.

• Tool definitions live at the front of context, so edits invalidate the cache.

• Earlier steps may reference tools no longer present, creating confusion.

Better: mask tokens during decoding. Constrain choices without reshuffling the context.

3. Externalize memory.

Even million-token windows fill fast with PDFs, codebases, or web pages. Compress too aggressively and you lose critical details.

We can solve this by treating the file system as context.

• Keep the URL or path.

• Reload details on demand.

This approach makes context management restorable rather than destructive.

4. Manipulate attention.

Using a process known as intentional compaction, we can manipulate an agents attention by creating a progress.md file and updating it step by step. By rewriting the plan and appending it to the end of the context, we can keep global goals in short-term attention—avoiding “lost in the middle” drift.

5. Preserve errors.

Developers instinctively sanitize traces, but errors are valuable signals. Leaving failed actions in context helps models implicitly adjust and avoid repeating mistakes.

6. Break the pattern.

Few-shot prompting can trap agents in brittle mimicry. Agents can sometimes fall into repetitive loops when reviewing something like resumes. Introducing small variations—different serialization formats, alternate phrasing—can keep them from overgeneralizing.

Scaling the Craft into Real Systems

Micro-level practices only go so far. Scaling agents requires macro-level structure. That’s where compaction comes in.

Many teams now use research → plan → implement cycles, with compaction baked into the workflow.

• Each phase produces structured artifacts (summaries, plans, logs).

• Utilization stays in the 40–60% sweet spot.

• Subagents handle exploration and summarization so the main loop doesn’t drown in detail.

Infrastructure reinforces these habits:

• Retrieval has evolved to hybrid dense + sparse with reranking.

• Memory is two-tiered: short-term in context, long-term in external stores.

• Tool catalogs are typed schemas with constraints, enforced through logits instead of edits.

What hasn’t worked—at least not yet—is multi-agent parallelism. Splitting tasks across agents looks promising but context sharing is too shallow. Subagents misinterpret subtasks, leaving the final agent to reconcile inconsistencies.

For now, the most reliable systems remain single-threaded agents with disciplined context management.

The Industry Direction

Big players are converging on context as the runtime:

• OpenAI: structured outputs and evals to shape and verify context.

• Anthropic: cheaper long context, constrained tool use, “computer use.”

• Google: Gemini embedded into Chrome, turning browser state into context.

Frameworks are racing to keep up:

• LangGraph for stateful flows.

• DSPy for compiled context pipelines.

• LlamaIndex for retrieval and memory.

Governance is catching up too:

• OWASP warns about context injection.

• NIST frames context as a security boundary.

The message is clear: models may dominate the headlines, but context is where engineering actually happens.

Emerging Best Practices

A playbook is starting to form:

1. Engineer layered recipes: system rules → state → facts → tool schemas → output contract.

2. Compact by default, not as a last resort.

3. Preserve errors and variation rather than sanitizing traces.

4. Treat context as an artifact: version it, test it, evaluate before shipping.

5. Harden context boundaries: allow-lists, redaction, sandboxing.

Context as the Real Engine

It’s tempting to think bigger models will solve everything.

But frontier lessons—from KV-cache discipline to file-based memory to recitation and error preservation—show otherwise. Models keep getting smarter. Yet the real bottleneck isn’t intelligence. It’s context.

And that’s the point: the future of AI agents won’t be decided by parameter counts. It will be decided by how well we engineer the context they run on.

Imagine an AI that doesn’t just generate text, but clicks through forms, books flights, files expense reports, or troubleshoots a bank error. Instead of staying inside the chat window, it’s navigating the web like a digital intern.

This shift—from passive chatbot to active web agent—signals more than a cosmetic change. It reflects a broader bet in Silicon Valley: that reinforcement learning (RL) environments modeled on the web will train LLMs to become true doers.

From Chatbots to Web Agents

Chatbots were the first wave. They impressed with fluent conversation, but stalled when tasks required action rather than words. Web agents are the natural evolution, combining language fluency with the ability to execute: navigating cluttered websites, extracting information, and completing multi-step workflows.

If Atari games and Go boards were early RL proving grounds, today’s equivalent is the open web. Just as flight simulators gave pilots a safe environment to practice, the browser is becoming the training simulator for the next generation of autonomous web agents.

Why Reinforcement Learning Environments Are Central

LLMs trained only on static text can predict but not practice. To function in real-world settings, they need experience. The web, with its shifting layouts and unpredictable edge cases, is ideal for this.

That’s why researchers are creating RL environments like WebArena, MiniWoB++, BrowserGym, WebVoyager, and WebAgent-R1. These sandboxes let agents make mistakes, learn from feedback, and steadily improve at real-world navigation. The principle is straightforward: if an AI can manage the chaos of the web, it can manage the chaos of work.

The Silicon Valley Bet

Investment is accelerating. Startups like Adept, Rabbit, and Emergent Mind are raising capital on the promise of web navigation. The opportunity is massive: whoever cracks this space could own the interface layer for billions of workflows—shopping, booking, research, customer service.

As LLMs brought NLP researchers to prominence, RL specialists are now returning to the spotlight. Silicon Valley is betting that RL environments—long overshadowed—are the missing link to the next productivity boom.

Technical Breakthroughs Making It Possible

Several advances are turning demos into practical systems:

• Context compression: enabling agents to process long, messy web pages without exceeding token limits.

• Planning scaffolds: chain-of-thought reasoning and planning tokens give agents foresight.

• Human-in-the-loop reinforcement: corrective feedback boosts both accuracy and training data.

• Hybrid browsing + APIs: combining UI interactions with direct API calls improves efficiency.

• Extended horizons: allowing more steps and retries leads to higher success rates.

Challenges and Open Questions

But hurdles remain:

• Generalization: Training on 50 curated sites doesn’t guarantee performance across millions of live websites.

• Safety: Agents capable of clicking, typing, or purchasing must be prevented from harmful or costly mistakes.

• Economics: RL at web scale is compute-intensive and expensive.

• Openness: While projects like BrowserGym are public, proprietary datasets may remain closed, limiting access.

Implications: A Browser-Native AI Future

If successful, the browser could shift from a tool we use to an arena where AI learns and works on our behalf. Enterprises might automate complex workflows and QA processes. Individuals could offload bureaucracy—tax forms, shopping carts, healthcare portals.

The broader vision: the web as a universal training ground for AI agents, where machines learn as humans did—by fumbling through forms, clicking wrong links, and gradually improving.

Where the Browser Leads

The rise of web agents signals a broader shift: AI is moving from conversation to execution, from answering questions to completing tasks. The browser—long the interface between humans and the digital world—is now becoming the training ground for machines that can learn, adapt, and act on our behalf.

If these systems succeed, they won’t just make browsing easier; they’ll reshape how work gets done, how businesses operate, and how individuals navigate daily life. The web taught us how to live online—now it may be teaching AI how to work alongside us.

Today, damages can reach $150,000 per work, regardless of actual harm. That framework may work for a film or a song, but it breaks down in AI, where models consume billions of words to extract patterns rather than reproduce originals.

• Piracy? Clearly illegal.

• Training on data to generate something new? Far murkier.

Copyright law simply wasn’t built for machine learning.

The Avalanche of AI Copyright Suits

Anthropic is only the beginning. OpenAI, Microsoft, Meta, Midjourney, and Apple are all under fire. The New York Times alone is seeking billions. More than 40 lawsuits are pending, with damages estimated in the trillions.

History shows why this matters:

• Google Books was sued for scanning millions of works. Courts ruled it transformative.

• Sega v. Accolade and Sony v. Connectix upheld reverse engineering as fair use, enabling new markets.

Fair use has historically unlocked innovation. Without it, search engines, image databases, and software ecosystems may never have scaled. The danger now: AI could be throttled by years of litigation before clarity emerges.

The China Factor: Litigation as Self-Sabotage

While U.S. firms fight in court, China is accelerating AI development:

• The state is building centralized “data exchanges” to ensure researchers and companies have access to massive datasets.

• Enforcement of IP rules is lax when it comes to training data. DeepSeek openly cited Anna’s Archive (a pirated library) as part of its training set.

• Beijing’s concern isn’t copyright—it’s ideological control.

Bottom line: Chinese labs keep training while U.S. firms hire lawyers. Every lawsuit in San Francisco is effectively a gift to Beijing.

National Security and AI

AI isn’t just about chatbots—it’s a dual-use technology with massive military implications. Autonomous logistics, targeting, and decision-support systems will shape future wars.

Here’s the irony:

• The U.S. spends billions restricting China’s access to advanced semiconductors.

• At the same time, U.S. courts risk choking American AI firms with copyright claims.

One side faces export controls, the other legal handcuffs. The outcome is the same: a weaker U.S. edge.

Policy Paths Forward

Three levers could resolve the crisis:

• Courts should reaffirm that AI training is transformative fair use, while punishing piracy.

• Congress could modernize copyright law with compulsory licensing or data trusts.

• The Executive Branch could go further: some argue the Defense Production Act should be invoked to compel reasonable licensing in the name of national defense.

Meanwhile, other countries aren’t waiting. Japan, Singapore, and Israel already allow AI training on copyrighted data. If the U.S. stalls, talent and capital will migrate.

The Bigger Picture: Creativity, Compensation, and Progress

Yes—authors deserve protection from outright piracy. A world where creative work can be stolen wholesale is untenable.

But it’s equally untenable to impose costs so high that innovation stalls. History shows this pattern: radio, film, and search engines all collided with copyright before finding equilibrium. AI now stands at the same inflection point.

The challenge is to design mechanisms that compensate creators without shackling progress—whether through revenue-sharing, opt-out registries, or collective licensing.

Copyright as the Decisive AI Battleground

The Anthropic case is a canary in the coal mine. It doesn’t settle the question of fair use in AI training, but it shows how fragile America’s lead could become if lawsuits drag on.

The real risk: The U.S. loses not because China is stronger, but because its own legal system strangles innovation.

Copyright was meant to spur creativity. The test now is whether it can evolve to support the next era of human and machine intelligence. If it can’t, the decisive obstacle in the AI race won’t be China at all—it will be the United States itself.

That equation has flipped. AI copilots now generate code from natural language prompts, and autonomous agents can spin up prototypes in hours that once took weeks.

The scarce resource is no longer the ability to build. The scarce resource is clarity—knowing what to build.

This is where product management comes in. Far from being replaced by AI, product management is becoming more critical than ever. As the cost of development collapses, the penalty for building the wrong thing grows.

In a world where anyone can ship software, the leverage shifts to judgment, prioritization, and orchestration—the very skills great product managers bring.

Economics of Cheap Code

There’s a simple principle at work: when the price of a complement good falls, demand for the paired good rises. Cars became cheaper, and gasoline demand soared.

Code is getting cheaper, which means demand for clear product specifications will spike.

• History shows that efficiency drives more consumption, not less.

• AI coding tools are proof: teams use it not only to speed up existing work, but to justify experiments and side projects that once seemed too costly.

The floodgates are opening, and every new idea will need someone to decide if it deserves the time, the data, and the user’s attention.

The Expanding Role of AI Product Managers

AI product management isn’t just traditional PM with a new focus—it requires a broader skill set.

A great AI PM must master:

• AI literacy – understanding what models can realistically achieve and how lifecycles work.

• Iterative development – working through trial-and-error cycles of training and tuning.

• Data fluency – designing, sourcing, and governing datasets.

• Ambiguity tolerance – navigating unpredictable model outcomes.

• Responsible AI – balancing innovation with trust, bias mitigation, and guardrails.

The Tension: Engineers vs. PMs in an AI World

Engineers are adapting to AI faster than PMs. They already think in abstractions and now have copilots to extend their leverage. In many startups, technical founders double as PMs by default.

This creates a tension:

• Will engineers absorb more of the PM role?

• Will hybrid “builder-PM” roles emerge, blending prototyping and strategy?

• Or will PMs evolve into orchestrators of multi-agent workflows, focusing on where automation ends and human value begins?

However it plays out, the underlying function—deciding what to build—doesn’t disappear. It becomes even more valuable as possibilities expand.

Career Implications: The Rise of the AI Product Manager

Demand for AI-literate PMs already exceeds supply, and the gap is widening. Companies don’t just need backlog managers; they need PMs who can prototype with AI tools, understand model limitations, and translate research into user value.

Tomorrow’s PM job description will include:

• Prompting agents and stitching together no-code workflows.

• Continuous discovery at the pace of AI’s evolution.

• Acting as translators between AI researchers and end users.

• Creating MVPs (vibe-coding!) to drive alignment

Example: Spotify’s personalization systems. PMs there balanced cutting-edge AI with user trust, ensuring personalization didn’t sacrifice transparency or control.

Beyond Software: AI PMs in Robotics and Physical Systems

The influence of AI PMs extends beyond software. As AI powers robotics, logistics, and autonomous systems, the role expands into domains where errors carry higher costs.

A buggy app can be patched overnight. A buggy robot can cause injury, disrupt supply chains, or trigger regulatory backlash.

Key challenges for PMs in physical AI systems:

• Safety and regulation – self-driving cars must meet NHTSA and EU rules; surgical robots face FDA approvals.

• Hardware-software integration – balancing AI ambition with edge hardware limits like latency and power.

• Ethics and liability – deciding who’s accountable when machines err, and ensuring explainability.

• Testing constraints – you can’t A/B test braking systems on highways; PMs must rely on simulation and staged rollouts.

Example: autonomous driving. A PM isn’t just prioritizing lane-keeping features—they’re defining data strategies, weighing predictive performance against safety guarantees, and coordinating across regulators, hardware vendors, and software teams.

This logic applies equally to industrial robotics, drones, and even consumer devices. In these contexts, PMs don’t just define product-market fit—they define the boundaries of what’s safe, legal, and possible in the physical world.

A Great Time to Build (and Manage)

AI is collapsing the cost of building while magnifying the cost of building the wrong thing.

That makes product management not less relevant, but more essential. The leverage point has shifted from code to clarity, from engineering velocity to product judgment.

For those who can combine technical fluency with product intuition, this is the best time in history to be a product manager.

The future isn’t just faster code—it’s smarter choices. And those choices will belong to AI Product Managers.

The trail up Mont Blanc is long enough for your mind to wander. The crunch of gravel under boots, the smell of pine mixed with cold air, the ridgelines catching late afternoon light—every step reminds you that this is more than landscape, it’s story.

At first, I tried plaques and guidebooks. They offered dates and names, but little life. What I wanted was legend: the kind of tale that makes mountains feel inhabited by spirits and giants. So I opened ChatGPT and asked it to retell the history of the Alps like a myth.

What came back made me very excited.

Long before men gave names to peaks, before France, before Switzerland, before the word "Alps" was ever written, the valley you now enter was said to belong to giants and spirits of ice. The Druids of the Celts whispered that the glaciers were living gods: slow, white, patient, devouring forests, grinding rock into dust. The locals left offerings at springs and caves to keep the mountains appeased.

The mountains suddenly weren’t scenery, they were characters in an unfolding epic.

From Prompts to Legends

What surprised me most was how little prompting it took. I didn’t need elaborate instructions. I simply told ChatGPT where I was and asked for a story in the style of a legend.

The outputs weren’t summaries. They read like oral tradition—shepherds outwitting glaciers, spirits carving valleys with their steps. Anchored in fact, yet shaped with arcs and imagery that stuck.

It all began with something mundane: a public notice about the distribution of firewood. I asked ChatGPT to translate it. Not only did it translate and explain the notice, it ended with a follow-up: Would you like me to explain what bourgeois means in the Swiss context?

That aside pulled me deeper. I wanted to know how Switzerland was formed, why it has always remained neutral in wars, and what stories might explain those choices. One question sparked the next, until I was hiking not just through the Alps, but through centuries of history reframed as folklore.

High above the world, where peaks cut the sky and rivers roar down to the plains, the Alps whisper their secrets. They have stood longer than empires, longer than kings, longer than the very stories men tell.

They speak of tribes who came with fire, of legions who marched in iron, of shepherds who swore oaths by moonlight, and of a people who decided, not to conquer, but to endure.

This, traveler, is the tale of Switzerland—a land whose mountains made it proud, whose valleys made it stubborn, and whose choice of neutrality became its greatest weapon.

Legends on Demand

Anywhere you travel, the same process works. Take a photo of a sign. Ask ChatGPT to translate it, then spin it into myth. Instead of learning that “this bridge was built in 1820,” you might hear:

The first alpinists—Balmat, Paccard, Saussure—passed here on their way to Mont Blanc. Bandits haunted them. Merchants cursed them. Engineers dreamed of taming them. From 1825 to 1957, the Forclaz road was fought over, carved, rebuilt, abandoned, and reborn. Today, it survives as a path of memory, where hikers trace the footsteps of centuries.

As I moved along my journey, I tailored the requests. “Going to Montroc by cable car—give me a two-hour saga weaving historic tales of the region.” Later, when I arrived at a guesthouse marked Gîte-Refuge Le Moulin, I asked ChatGPT to translate the sign.

It didn’t stop there. At the end of its response, it asked if I also wanted it to compare Le Moulin to higher mountain refuges. I followed up: “Tell me fables and stories from Le Moulin—two hours.” What came back was a saga in which the mill itself became a character, its stones echoing the voices of peasants, pilgrims, smugglers, mountaineers, and spirits.

Imagine yourself stepping into Le Moulin at dusk. Wooden beams creak, the scent of soup and cheese drifts from the kitchen, boots lie drying by the door. A fire burns low, and a voice begins to speak:

"I am the Mill of Montroc. My stones were set when the valley was young, when the river still sang wild and untamed. Through my wheel has passed not only grain, but the stories of all who dared this valley. Tonight, I will tell them to you."

When the tale finished, ChatGPT asked: Do you want me to also layer in historical fact markers—like who actually owned mills in Montroc, or documented smugglers’ routes through Col de Balme—so you can separate legend from record while still enjoying the fable?

I said yes. The result was a series of fables about Le Moulin, now woven with historical anchors. And since my journey also took me toward Martigny, I asked it to bring that destination into the saga as well. The story expanded, just as the landscape did, one stop blending into the next.

Tonight our stage is small and grand at once: Montroc, where a mill’s old wheel still creaks in dreams; Trient, whose dark firs hide herbs and secrets; Martigny, the spider in the web at the bend of the Rhône; and the passes—Balme, Forclaz, Tête Noire—the narrow doors between worlds. Our actors are a miller’s daughter, a healer called witch, a captain who hunts what he envies, a bandit who howls with the wind—and a smuggler who leaves a promise where edelweiss should not grow.

From Reading to Listening

At first I read the stories. Then I tapped the audio button and heard them spoken aloud. That one shift changed everything.

Walking with narration in my ears made the Alps feel less like rock and ice, more like participants in the tale. The sigh of wind through a pass echoed the breath of the ancient giant ChatGPT had just described. My footsteps aligned with the cadence of the spoken words. The landscape became part of the story.

Building Sagas That Last

Sometimes the tales came back scattered—a handful of fables rather than a continuous arc. That’s where refining prompts made all the difference.

“Write this as a continuous saga,” I’d ask. Or: “Give each character their own story, then weave them together at the end.” Suddenly, the fragments became a tapestry: recurring heroes, evolving conflicts, legends that connected.

On longer treks, I even asked ChatGPT for three- or four-hour sagas that blended facts, myths, and invented characters. What came back felt serialized, like epics told over many nights in an alpine inn while storms rattled the shutters outside.

The miller’s daughter was Marianne—light on her feet, iron in her eyes. In the gray light of mornings she tied her hair with a strip of linen and went outside to listen to the water. “It talks,” she said once to her father. “It tells which day will be easy and which will be hard.” He laughed, as fathers do at daughters who know too much.

Practical Tips for Story Travelers

If you want to try this yourself:

• Start simple. Tell ChatGPT where you are and what style of story you’d like.

• Experiment with modes. Legends for grandeur, myths for symbolism, fables for lessons, folklore for cultural detail.

• Adjust the length. A quick fable for a stroll, a saga for a long hike.

• Add local details. Mention landmarks, weather, even your mood.

• Refine if needed. Ask for a continuous arc, or stories woven from individual characters and places.

A Bard in Your Pocket

Hiking Mont Blanc with a saga in my ears didn’t feel like technology. It felt ancient. Humans have always told stories to make sense of the world. What’s different now is that with a few words to ChatGPT, you can have those stories tailored to your journey, narrated aloud as you walk.

Used this way, ChatGPT isn’t just a language model. It’s a bard in your pocket—one that travels with you, spinning myths from your surroundings. Technology is often accused of pulling us away from the moment. But here, it did the opposite. It pulled me closer, revealing the legends hidden in the silence of the mountains.

For three decades, the web ran on a simple bargain: publishers created content, search engines indexed it, and traffic flowed back in return. That loop sustained everything from personal blogs to billion-dollar media empires.

AI is breaking that deal. Google’s AI Overviews and new “AI Mode” summarize answers directly in search results, often removing the need to click through. An analysis conducted by Ahrefs of 300,000 keywords shows a 34.5% drop in clicks for pages competing with AI Overviews. If featured snippets drained traffic, AI Mode threatens to pull the plug entirely.

The question is no longer whether AI will reshape the web, but what kind of web will remain when it does.

From the Human Web to the Machine Web

We’re entering what might be called the “machine web.” Instead of building sites for people, publishers are increasingly optimizing for AI crawlers and agent-friendly formats.

In this world, information isn’t discovered so much as consumed by machines. Rather than browsing blogs, forums, or niche communities, users receive synthesized answers from AI. Publishers don’t compete for human attention; they compete to be included in training data or cited in AI-generated responses.

The gains are clear: speed, convenience, and automation. The losses are harder to quantify: serendipity, diversity, and the sense of the web as a living ecosystem.

Beneath it all lies the real shift: control is moving from humans navigating links to AI managing workflows.

Google’s Gamble: AI Overviews and AI Mode

At Google I/O this May, Sundar Pichai unveiled “AI Mode,” a chatbot interface that replaces traditional search listings. Instead of a page of links, you get a generated article.

Google says this makes search more useful. Critics see it as an existential threat. SEO strategists warn that traffic to independent publishers could collapse. Small businesses fear their products will be summarized away before anyone reaches their site.

Google argues that the clicks that do happen are “higher quality.” But the economics remain unchanged: if AI answers the question, fewer people click. And if fewer people click, the ad-driven web begins to starve.

For two decades, Google has been both the sun and the soil of the open web. Now it risks becoming the shadow looming over it.

The Rise of AI Agents as Browsers

While Google redefines search, others are reinventing the browser. Perplexity’s Comet, OpenAI’s upcoming browser, Microsoft’s Edge with Copilot, Opera’s Aria, and Brave’s Leo all push beyond passive navigation.

These tools are not just browsers. They are action engines. You can ask Comet to find a confirmation email, summarize an article, book a flight, or order a product. OpenAI’s version is designed to keep you inside a ChatGPT-style interface where an agent handles tasks directly.

The paradigm is shifting: less “search and click,” more “ask and delegate.” Browsers are moving from displaying content to performing work.

The Antitrust Wildcard: Chrome in Play

Google’s timing could hardly be worse. After being found guilty of illegally monopolizing search and ads, the Department of Justice may force it to sell Chrome.

If Chrome—the browser used by more than 3 billion people—changes hands, the balance of power shifts dramatically. OpenAI, Perplexity, Yahoo, and even Search.com have expressed interest. For OpenAI, Chrome would instantly fuse ChatGPT with the most popular browser on earth. For Perplexity, it would be a springboard to challenge Google directly.

The browser isn’t just software. It is distribution. Whoever owns Chrome controls the front door to the web.

Browser War 3: What’s Really at Stake

Think of the browser wars as a three-act story:

• Browser War 1: Netscape vs Internet Explorer, won through distribution.

• Browser War 2: Internet Explorer vs Chrome, won through speed and simplicity.

• Browser War 3: Google vs everyone else, with victory hinging on answers, agents, and automation.

This round isn’t about tabs or rendering speed. It is about who becomes the trusted intermediary between human intent and machine execution.

The winner won’t just gain market share. They will define the next interface of the internet.

The Business Model Cliff

If AI handles most queries directly, where does that leave publishers?

Some strike licensing deals: The New York Times with Amazon, Reddit with Google, others with OpenAI. But these arrangements are reserved for giants. Smaller publishers are being hollowed out.

The reality is simple: robots don’t click ads. If bots become the main “audience,” the ad-driven model collapses. No one has yet offered a viable replacement.

The result is a cliff edge. Content creators need revenue to survive, but AI is diverting traffic away. Something has to give.

The Future of Interfaces: Agent-Friendly by Default

Look ahead a few years and the trajectory is clear. Websites will be designed less for human browsing and more for agent access.

Instead of clicking through a travel site, your AI agent will call an endpoint and book the trip. Instead of scrolling Amazon, it will fetch the best option and place the order. The human front end becomes optional—an API for machines to negotiate on our behalf.

The hyperlink-driven metaphor of “browsing” may soon feel as dated as dial-up. The new interface of the internet could be an AI conversation layer that hides the page entirely.

The Machine Web Arrives

The open web isn’t gone, but it is being rewritten.

The winners of the new browser wars won’t just control distribution. They will own the interface between human intent and machine execution. For businesses, that means fewer direct clicks, more intermediated traffic, and the need to design for agents as much as for people.

The last browser wars decided how we saw the web. This one will decide whether we keep seeing it at all.

When I was at Stanford, Fei-Fei Li’s lab was one of the most sought-after in vision AI. She and her students were pioneering the use of large-scale datasets to give models a richer, more grounded understanding of the world. That work showed me early on that data isn’t just fuel—it’s the bridge between abstract algorithms and real-world perception.

Language is one of humanity’s most remarkable inventions, bridging the conceptual and physical worlds. It lets us share ideas, coordinate across distances, and preserve knowledge. But it is also an imperfect, lossy compression of reality.

Say, “A red ball rolled across the table.” You picture the scene—but the actual state is far richer. The ball’s precise weight, spin, and speed; the table’s exact surface friction and position; the shifting pattern of shadows—all of it disappears in the compression into words.

Humans don’t notice because we bring a lifetime of shared, implicit knowledge to fill the gaps. AI models trained purely on text don’t have that luxury. Their reasoning is limited by the bandwidth of language.

That’s where world models come in. Instead of reasoning only from symbolic descriptions, they maintain a rich, spatially grounded, temporally coherent representation of the environment—whether physical or virtual. Think of it as an internal canvas that preserves the details language leaves out.

What is a World Model?

A world model is a learned internal representation that predicts how the environment changes over time and under different actions. It merges perception, memory, and prediction into a single latent space.

A world model is an internal representation that predicts how an environment changes over time and in response to actions. It blends perception, memory, and prediction into a single latent space.

Early work—like Ha & Schmidhuber’s World Models (2018) and the PlaNet and Dreamer series—proved an agent could learn latent dynamics directly from pixels and use “imagined rollouts” to plan its next move.

Today, models such as DreamerV3, OpenAI’s Sora, and Wayve’s GAIA-2 operate over multi-modal, 3D-aware scene representations, giving them far richer predictive power.

The key distinction: language is a symbolic snapshot; a world model is a continuous simulation.

Spatial Intelligence: The Antidote to Lossy Encoding

The reason world models matter is that they give AI spatial intelligence—the ability to reconstruct what language leaves out. A capable model can:

• Infer 3D geometry and relationships from multiple viewpoints and sensors.

• Maintain object permanence, tracking items even when they’re out of sight.

• Predict physical interactions, such as whether stacked boxes will topple.

• Anchor reasoning in egomotion and spatial memory, so it knows not just what it sees, but where it is in relation to everything else.

This closes the gap between what’s said and what’s true. If you tell it, “Put the mug back where it was,” a language-only model might not know the “where” without explicit coordinates. A world model can recall its last known 3D location.

Put another way: Language is a codec for communication. World models are a codec for reality.

Architecture of a Spatial World Model

A modern spatial world model has several key layers:

1. Representation Layer
   NeRFs, Gaussian Splatting, and Bird’s-Eye-View (BEV) latents create dense, geometry-aware scene representations. These preserve spatial structure far beyond what text can describe.

2. Object-Centric Backbone
   Slot Attention and similar methods factor the scene into discrete entities with attributes and relationships, enabling compositional reasoning.

3. Dynamics Model
   Latent state-space architectures (Dreamer-style) predict how states evolve under actions, allowing the model to “imagine” future scenarios before acting.

4. Learning Signals
   Self-supervised video objectives and predictive training (e.g., JEPAs) teach the model to anticipate changes and respect physical constraints without labeled data.

In this architecture, language is an adapter layer—a way to query or update the rich latent state, not the core reasoning medium. A language instruction is parsed into this richer spatial state, where planning and reasoning occur.

The Language → World Model → Action Loop

The process typically unfolds as follows:

1. Language Input (lossy): Human provides an instruction, e.g., “stack the boxes in the corner.”

2. Language-to-State Adapter: Parses the instruction and grounds terms like “boxes” and “corner” in the current scene representation.

3. World Model Core: Maintains a multimodal, 3D state, including object positions and free space.

4. Simulation & Planning: Runs imagined trajectories to evaluate possible stacking sequences for stability.

5. State-to-Action Adapter: Converts the chosen plan into motor commands, code, or virtual events.

6. Perception Feedback: Updates the state using vision, depth, or tactile data, correcting for deviations.

By keeping perception in the loop, the model avoids drifting into purely symbolic reasoning and remains grounded in the physical or simulated reality it inhabits.

Applications Across Real and Virtual Worlds

In the physical world:

• Robotics: Interprets vague instructions like “pick up the mug” by inferring shape, position, and how to grasp it safely.

• Autonomous driving: Predicts how the road scene will evolve, from vehicle trajectories to pedestrian movement.

• AR devices: Grounds ambiguous commands like “highlight that route” to specific visual elements in a user’s view.

In virtual environments:

• Games: Generates coherent environments and NPC behaviors from incomplete scripts.

• Digital twins: Models factories, supply chains, or city systems with spatial and temporal accuracy.

Bridging the two:
Domain randomization, embodied pretraining, and continual learning help models transfer what they’ve learned in simulation to the real world without catastrophic failure.

Strategic Implications and What’s Next

Relying solely on language locks AI into its inherent bottleneck. Pairing language with a world model unlocks a high-fidelity mental map that enables safer, more adaptable, and more general decision-making.

In this setup, language serves best as the interface layer, not the reasoning substrate—especially in high-stakes domains like autonomous fleets or surgical robotics, where every decision must be grounded in reality.

Over the next 12–24 months, expect this approach to accelerate:

• Object-centric + 3DGS pipelines will become the default for spatial reasoning, combining semantic understanding with precise geometry.

• Action-aware video world simulators will merge controllable dynamics with photorealistic rendering, narrowing the gap between generative models and deployed agents.

• Shared scene/state schemas will allow multiple agents to collaborate on a single, unified representation of the world.

Benchmarks will evolve to measure physics and causal reasoning, moving beyond static perception tests toward evaluating true real-world competence.

Closing Thoughts

Language will remain the bridge between humans and machines—but it is not the world itself. By design, it strips away much of the spatial, physical, and causal richness needed for robust action.

World models restore that richness. They let AI think in full fidelity, simulate plausible futures, and act with precision in both physical and virtual domains. As these models advance—fusing object-centric reasoning, high-fidelity geometry, and action-aware simulation—they will move us closer to AI systems that can operate confidently in the messiness of the real world.

Language is for telling. World models are for knowing. The AI systems that matter most will be fluent in both—communicating in words when they interact with us, but thinking in worlds when they act for us.

Google’s MedGemma—a new suite of open medical vision-language models—isn’t just another research benchmark. It’s a practical, open-source toolset that outperforms many proprietary systems, especially in the high-stakes realm of clinical reasoning, medical imaging, and agent-based healthcare workflows.

We’ve seen AI transform industries like finance, logistics, and entertainment. But medicine has resisted (rightly) because precision matters and general-purpose models often fall short. With MedGemma, we’re seeing that change.

From Stanford Prototypes to Foundation Models

Years ago, I worked on a project at Stanford using classic ML to label chest X-rays. It felt ambitious, even if the results were limited. Around the same time, we ran a hospital proof-of-concept with Google Glass. Great idea, wrong decade.

Fast forward to today. Instead of hand-labeling data, we’re training multimodal transformers on 33 million image-text pairs. And instead of struggling with brittle models that break when conditions shift, we’re seeing robust, fine-tuned systems that hold their own against human experts. The pace of progress has been staggering.

What Is MedGemma?

At a high level, MedGemma is built on top of Google’s Gemma 3 foundation models (4B and 27B variants) and extended with a medically tuned vision encoder called MedSigLIP. This combination allows it to perform joint reasoning across clinical images, patient notes, medical questions, and structured records.

The suite includes:

• MedGemma 4B Multimodal – Lightweight, image+text model for rapid deployment

• MedGemma 27B Text-Only – Optimized for long-form clinical reasoning and EHR interpretation

• MedGemma 27B Multimodal – High-performance model for dense image+text inference

Technical Deep Dive: How to Build a Model That Thinks Like a Clinician

What makes MedGemma notable isn’t just performance—it’s how it was built.

Step 1: Train the Eye (MedSigLIP)

First, Google adapted SigLIP, their general-purpose vision model, using over 33 million medical image-text pairs. This included 635K examples from radiology, dermatology, and ophthalmology, plus 32.6M histopathology slides. Crucially, they retained a portion of the original WebLI training set to maintain general vision competence.

The result is MedSigLIP, a 400M parameter encoder that not only performs better on medical image classification than task-specific models but still handles natural images when needed. It’s lightweight, robust, and fully open.

Step 2: Connect the Eye to the Brain

With the visual side sorted, the team retrained Gemma 3 checkpoints using the new image-text pairs. To preserve general reasoning capabilities, medical data was weighted at just 10%. Enough to learn the language of medicine, but not enough to forget everything else.

Step 3: Fine-Tune the Behavior

Finally, the team used two stages of post-training:

• Distillation: To kickstart its clinical reasoning, the team used distillation—training MedGemma on question-answer pairs originally generated by a much larger, more capable teacher model. It’s a shortcut to transfer expertise without brute-force retraining.

• Reinforcement Learning: To sharpen its responses in multimodal settings, the team applied reinforcement learning—not just to boost accuracy, but to help the model generalize beyond the training set.

  It turned out to be more effective than standard supervised tuning, especially for the edge cases that matter in clinical work.

Together, this created a model that not only understands clinical text and images—but reasons about them the way a human doctor would.

Benchmark Results

Across every key medical AI benchmark, MedGemma performs near the top—often beating much larger, closed-source models:

• MedQA: 87.7% accuracy (MedGemma 27B), within reach of GPT-4-level systems.

• MIMIC-CXR Classification: 88.9 macro F1, outperforming Gemini 2.5 Flash and Gemini 2.5 Pro.

• Visual QA: Best-in-class zero-shot scores on SLAKE and VQA-RAD.

• AgentClinic: 56.2% vs 54.0% human average—yes, it beat the doctors.

• Radiology Report Generation: 30.3 RadGraph F1 after fine-tuning.

• General Tasks: Strong performance on MMLU, MMMU, and PubMedQA shows it hasn’t lost generality.

Real-World Applications

What’s most exciting isn’t just the benchmarks—it’s the use cases:

• Clinical Report Generation: MedGemma can draft imaging reports with 81% rated as equivalent to radiologist-written versions.

• Pre-Visit Intake Agents: Automatically gathers and summarizes patient info before appointments.

• EHR QA: Reinforcement-tuned model reduced error rates in synthetic EHR queries by nearly half (86.3% → 93.6%).

• On-Device Triage Tools: With a 4B parameter option, MedGemma runs locally—no cloud API required.

Why Open Source Matters

Google’s decision to release MedGemma under an open license changes the game.

Hospitals can run the models on their own infrastructure. Startups can fine-tune them for niche domains. Researchers can build new applications without asking permission or paying API tolls. And critically, reproducibility and regulatory compliance are far easier with frozen weights than with opaque commercial endpoints.

Early adopters include DeepHealth (chest X-ray triage), Tap Health (clinical summarization), and Chang Gung Memorial Hospital (Chinese-language medical literature). The foundation is already spawning real-world tools.

Looking Ahead

MedGemma doesn’t replace doctors. But it does something almost as valuable: it makes expert reasoning more accessible, scalable, and composable. You don’t need to build an end-to-end system from scratch—you can start with a model that already understands medicine, then adapt it.

This is the shift we’ve been waiting for: from narrow, single-use models to true generalist platforms for clinical AI. As with the early days of ImageNet and BERT, the release of MedGemma is less about the current models than the ecosystem they’ll unlock.

Final Thoughts

When we started out building chest X-ray classifiers at Stanford, we had to fight for every percent of accuracy and hand-label thousands of samples. Today, MedGemma shows what’s possible when scale, compute, and medical context come together.

It’s not perfect. But it’s practical, performant, and—most importantly—open.

And in healthcare, that might make all the difference.

That world is quickly fading.

AI-assisted tools have made prototyping nearly effortless. Code can now be generated, tested, and discarded in hours. Teams routinely rebuild from scratch—not because something broke, but because starting over is often faster than maintaining technical debt. Prototypes that once took weeks now take a day.

And yet, despite all this acceleration, building still feels hard.

The bottleneck is no longer engineering. It’s clarity. As code becomes easier to write, the real constraint has shifted upstream—toward product management, decision-making, and judgment.

The Application Layer Is Where Leverage Lives

Most attention in AI still gravitates toward foundation models and custom silicon, but the real leverage is higher up the stack. The application layer is where user experience happens, where value is delivered, and where companies generate revenue. As infrastructure becomes increasingly commoditized, it’s the application layer that distinguishes winners from everyone else.

And building here is getting easier by the week. Developers can now stitch together systems using orchestration tools, agentic frameworks, and modular libraries for retrieval, evaluation, and embeddings. The days of building everything from scratch are mostly gone. The stack is more composable and forgiving than ever.

But ease comes with risk. When it’s easy to build anything, it becomes equally easy to build the wrong thing—and to waste time and resources doing it at scale. This is where judgment, product thinking, and feedback loops become vital.

Engineering Isn’t Slowing You Down

The traditional barriers to building have eroded. Thanks to AI-enhanced tooling, production-grade code is now 30 to 50 percent faster to write. For early-stage prototypes, teams can move ten times faster—or more.

Because these prototypes are often built outside of legacy systems, they’re light, disposable, and fast to iterate. What used to be multi-week architectural planning exercises can now be rebuilt from scratch in a few days. Decisions that once felt like one-way doors—hard to reverse, expensive to revisit—now feel more like pivots.

This isn’t just about speed. It’s about freedom. Engineering no longer dictates the pace of innovation. That responsibility has moved elsewhere.

Product Management Hasn’t Caught Up

While engineering has become dramatically more efficient, product management hasn’t kept pace. In some cases, the old ratios are reversing—teams are experimenting with more product managers per engineer, not fewer. It’s a sign of where the bottleneck has moved.

Why the imbalance? Because product decisions still take time. The ability to generate features now exceeds the team’s ability to frame, scope, and prioritize them. When ideas are vague, abstract, or loosely defined, engineers stall—not because they lack capability, but because they’re waiting for clear direction.

Modern product velocity isn’t about shipping faster documentation. It’s about shaping clear, testable hypotheses that guide the team toward fast feedback and meaningful iteration. It’s not about doing more—it’s about knowing what not to do.

Speed Comes from Specificity

At the heart of product momentum is specificity. The difference between an idea that ships and one that stalls is how clearly it’s defined.

“AI for healthcare” might sound visionary in a meeting, but it’s not actionable. In contrast, “a booking assistant that optimizes MRI scheduling to reduce patient wait times” is something an engineer can build today. One is a pitch. The other is a product.

Vague ideas generate enthusiasm, but rarely lead to output. Specific ideas create movement. And movement—not just inspiration—is what drives real learning and traction.

Judgment Is the New Differentiator

Despite our collective obsession with data, early-stage product decisions are rarely made with clean dashboards and tidy metrics. More often, they rely on fast, confident judgment.

Judgment isn’t guesswork. It’s the ability to recognize patterns, weigh tradeoffs, and move forward with limited information. And it’s earned through immersion, repetition, and user contact—not spreadsheets.

In a world where code is cheap and prototypes are fast, the bottleneck isn’t execution. It’s knowing what to execute. Teams that excel here rely on domain intuition, sharpened through firsthand experience and tempered by feedback—not just statistical significance.

Feedback Loops Are the Real Build System

Teams that move fast don’t just write code quickly—they learn quickly. They use feedback loops not only to validate ideas, but to refine their instincts.

Here’s a rough hierarchy of feedback methods, ranked from fastest to slowest:

• Trust your gut (if you’ve earned it)

• Ask a few close teammates

• Talk to strangers in real-world settings (coffee shops, lobbies)

• Share with a small group of users

• Run A/B tests—but only after everything else

Each method adds fidelity, but also introduces delay. The most valuable output from feedback isn’t always the answer—it’s what the data reveals about how well your team understands the user. A tight feedback loop doesn’t just resolve the current decision—it accelerates the next one.

AI Literacy Still Compounds

Knowing how to build with AI—not just use it—unlocks speed at a deeper level. The ability to choose the right building blocks, prompt strategies, or model integrations can save weeks. The wrong choice can lead your team down dead ends.

That’s why skills like prompt chaining, retrieval-augmented generation, evaluation frameworks, and modular architectures aren’t niche knowledge anymore. They’re foundational. Teams with this technical fluency don’t just move faster—they’re more resilient, more experimental, and better able to adapt.

And when systems are designed for flexibility, switching between models or tools becomes trivial. Momentum stays intact. Experiments stay cheap. Dead ends stay shallow.

Ethics Is a Product Question Too

Responsible development is no longer just the domain of legal or compliance teams. It’s a core product question.

The most important filter for any new idea isn’t just “Will it make money?” It’s “Should this exist?”

Plenty of ideas are viable. Far fewer are worthwhile. The best teams apply the same product rigor to ethical implications as they do to UX or market fit. They build for outcomes, not just output. And those are the teams that build software people trust.

Your Bottleneck Isn’t Technical

The infrastructure is in place. The tools are fast. The models improve weekly. If your team feels stuck, it’s not because of engineering—it’s because the product function hasn’t caught up.

Shipping isn’t the hard part anymore. Knowing what to ship, why it matters, and how to test it within days—that’s the new frontier.

If you’re still treating product management as a planning layer instead of a velocity engine, you're already behind. The constraint has shifted. The faster you adapt, the faster your team can move.

The internet wasn’t about websites; it was about fiber optics, data centers, and server farms. AI is no different. It may feel like a software revolution, but its future will be shaped by electricity and infrastructure.

We’re entering a new economic era, and AI is its engine. To understand where it’s going, we need to stop thinking in terms of code and start thinking in terms of concrete.

From Cloud to Compute: A New Infrastructure Layer

The cloud era taught us to scale elastically. Providers like AWS, Azure, and Google Cloud expanded rapidly, driven by a simple formula: more users created more data, which required more servers, and larger volumes brought costs down. This model worked well because cloud workloads ran on CPUs, which improved steadily in efficiency. You could pack more performance into each rack without a proportional increase in power.

AI upended that model.

Training large foundation models like GPT-4 or Claude demands compute at an entirely different scale. A single AI server rack today consumes up to 50 times more power than a typical cloud rack from just a few years ago. These aren’t just upgraded machines. They are densely packed GPU clusters that generate immense heat, requiring advanced liquid cooling systems to stay operational.

We’ve moved from hyperscaling to hypersaturating.

Inference adds another layer of complexity. As AI is deployed into real-time user applications, latency becomes critical. That requires infrastructure closer to the user, even as training continues in remote areas optimized for cheap power and open space. The result is a sprawling physical footprint—one that pushes both inward toward the edge and outward into low-density regions.

This isn’t just a technical transition. It’s a financial one.

AI Isn’t Replacing the Cloud. It’s Expanding It.

Rather than cannibalizing cloud budgets, AI is increasing them. Hyperscalers are expected to invest more than $1 trillion in AI infrastructure by 2027. Alongside them, a new class of “neocloud” players—AI-native infrastructure startups—is spending heavily to compete.

The economics have shifted. In the cloud era, most of the capital went toward the building itself: land, cooling, and power. Today, the hardware inside an AI data center often costs three to four times more than the structure around it. These assets are harder to underwrite, too. The pace of innovation has shortened the usable life of AI hardware to a few years at best.

This creates a new challenge for investors and lenders: how to finance assets that are both expensive and rapidly evolving.

The Power Constraint

This brings us to the most pressing limitation: electricity.

While AI races ahead, the U.S. power grid remains stuck in the past. Much of the infrastructure is over 40 years old. After a decade of flat demand, data centers are now driving a projected 160% increase in electricity use by 2030. Nearly 60% of that demand will need to be met with new power generation.

Capital isn’t the issue. Power is.

Utilities are already behind. Natural gas is resurging, while wind and solar continue to expand. But renewables are intermittent, and energy storage has yet to catch up. Nuclear energy is returning to the conversation, but high costs and long lead times limit its near-term viability. Even previously shuttered plants like Three Mile Island Unit 1 are being brought back online to help meet the need.

Faced with these challenges, some companies are taking matters into their own hands.

Behind the Meter: Controlling the Energy Supply

Many hyperscalers and infrastructure developers are moving "behind the meter"—generating their own power or buying it directly from nearby plants. This strategy cuts interconnection delays and offers greater control over energy reliability.

Turnkey providers like PowerSecure and VoltaGrid are enabling this approach. During the 2021 Texas winter storm, PowerSecure’s microgrids supplied more than 2 GWh of backup energy while the main grid failed. In the AI era, that level of resilience is no longer optional.

Still, these setups come with trade-offs. Projects like xAI’s Colossus facility in Memphis have faced local backlash over pollution concerns. And efforts to colocate data centers with nuclear plants have sometimes been blocked by regulators, citing risks to ratepayers and local infrastructure.

Nonetheless, energy autonomy is quickly becoming a strategic advantage.

The Geopolitics of Data Centers

Unlike oil fields, which occur naturally, data centers can be built anywhere power, land, and policy align. That makes them useful geopolitical assets.

Nations that host AI infrastructure gain more than just economic development. They strengthen strategic alliances and increase their influence in the global digital economy. Brazil, for example—where 90 percent of electricity is renewable—is becoming a hub for AI infrastructure in Latin America.

At the same time, cross-border expansion introduces new risks. Export controls, data localization mandates, and regulatory changes complicate international deployments. U.S. hyperscalers may lead in model development, but their ability to scale globally now depends as much on diplomacy as on technology.

Data centers are quickly becoming as important as embassies.

Rewriting the Capital Stack

At the center of all this is capital—and a lot of it.

Global infrastructure investment needs are staggering. Digital infrastructure alone will require an estimated $2 trillion by 2030. Add $3 trillion for power and utilities, and $12 trillion for the broader energy transition.

To meet these needs, capital formation is evolving. Joint ventures are combining real estate, sovereign wealth, and corporate leasing. Stabilized data centers are being securitized and sold as single-asset bonds. Insurance firms, pension funds, and even retail investors are gaining exposure.

Goldman Sachs, for example, recently launched a Capital Solutions Group to integrate advisory, origination, and capital deployment across both public and private markets. The goal is to reduce friction and match investors with the right part of the infrastructure lifecycle.

These are no longer niche financings. They are the backbone of the next economy.

Final Thought: AI Is Becoming a Utility

The next phase of AI won’t be won by whoever has the smartest model. That phase is already over. GPT-4, Claude, Gemini—they’re all impressive and largely interchangeable.

What matters now is what comes after the model. Electricity. Hardware. Real estate. Supply chains. Capital markets.

AI is becoming a utility. And like any utility, it depends on infrastructure. The companies that win won’t just build smarter models—they’ll master systems thinking across compute, power, and finance.

They’ll treat power contracts as product inputs.

They’ll build with watts in mind, not just weights.

And they’ll understand that in the AI era, the most important innovation may be knowing how to keep the lights on.

Sources: https://www.goldmansachs.com/what-we-do/investment-banking/insights/articles/powering-the-ai-era

Europe’s approach makes this clear. Take Schleswig-Holstein, Germany’s northernmost state. It’s making one of the boldest moves yet: replacing Microsoft’s entire suite — Teams, Office, Azure — with open-source alternatives.

This shift isn’t just about features or licensing costs. It’s about what happens when your data and operations run on servers outside your control during a geopolitical crisis. As their Digitalization Minister put it, “The war in Ukraine showed our energy dependencies — now we see our digital ones too.” That reality is driving the new wave of Sovereign AI and Sovereign Software Tools.

Sovereign AI: What It Really Means

Sovereign AI is more than keeping servers within national borders. It means building real local capability: training large language models on domestic data, deploying them on national infrastructure, and developing a workforce ready to innovate without relying on foreign providers.

For many countries, Sovereign AI is insurance. It ensures that the trillions in economic value AI is projected to generate don’t all flow outward to Silicon Valley or Shenzhen. It safeguards cultural nuance and local dialects that would otherwise be diluted by English-centric training data. And it guarantees that when a nation needs to scale for security or critical services, it won’t be waiting for computing capacity from someone else’s cloud.

Why Sovereign Software Tools Matter

If AI is tomorrow’s economic engine, then software tools are the steering wheel. Across Europe, governments are moving toward open-source tools for public administration. LibreOffice, Linux, OpenDesk, and XWiki are no longer fringe options. They are now strategic choices. When you add up licensing fees, data risks, and supply chain dependencies, owning the entire software stack makes sense.

Transitions aren’t always smooth. Munich’s early open-source project famously struggled, but it showed where real investment is needed: local support, upskilling public servants, and steady funding.

New initiatives, like France and Germany’s Docs project, are learning from that experience. They’re building collaborative tools that can match Notion or Google Docs, while staying firmly under local control.

The Main Drivers: Economy, Security, and Culture

Every push for digital sovereignty is grounded in three core motivations.

Economic Competitiveness. Generative AI is boosting productivity across industries, from coding assistants and legal research to fraud detection and biotech.

But if you rent your foundational models and pipelines from abroad, the economic returns go abroad too. Countries like India and Japan are betting that local LLMs, domestic GPUs, and national cloud capacity will keep that value at home.

National Security. The US Cloud Act allows American authorities to access data from US-based cloud providers, no matter where the servers are located. If critical national data lives on Azure or AWS, you’re already exposed.

Sovereign clouds and homegrown AI reduce the risk of sensitive information — from military plans to health records — becoming entangled in foreign legal battles.

Cultural Identity. This is easy to overlook but crucial. A model trained on local languages and contexts is more relevant and fair. Indonesia’s Bahasa-first models and Korea’s national LLMs reflect this.

These efforts aren’t symbolic; they’re how countries ensure AI aligns with local norms instead of flattening everything into generic English.

What Sovereign AI Looks Like in Practice

Many nations have already started building this future. France’s Scaleway is developing Europe’s largest cloud-native AI supercomputer. Swisscom is working on Italy’s first large-scale LLM trained entirely in Italian. In India, Tata Group and Reliance Industries are investing billions in AI infrastructure and models for the country’s many languages.

Japan isn’t just adding hardware; it’s rewriting its AI governance with their recent AI bill. The goal is clear rules, a strong talent pipeline, and domestic GPU capacity to support long-term independence. ASEAN countries are promoting open-source models and local hardware so local communities have a voice in how these systems learn.

Two Sovereign Cloud Models — And Their Tradeoffs

Sovereign AI depends on the cloud infrastructure beneath it. Some countries choose Hyperscaler Clouds with Sovereignty Features, like Singapore’s local AWS zones, which combine global tools with local data controls. This approach is quicker and less expensive but still depends on foreign operators.

Others prefer Sovereign Clouds with Hyperscaler Support. Germany’s partnership with Arvato, SAP, and Microsoft shows this model in action. Infrastructure and governance stay local, but governments license world-class software. The tradeoff is higher upfront costs, longer rollout times, and the need for local expertise to keep systems secure and current.

Six Strategic Pillars for Getting Sovereignty Right

Countries that succeed in digital sovereignty focus on the same six pillars:

1. Digital Infrastructure. Build local data centers, sovereign clouds, and edge computing that keep data within national borders.

2. Workforce Development. Invest in STEM education and lifelong AI training. Talent beats hardware every time.

3. Open-Source Ecosystems. Maintain vibrant communities that keep local alternatives competitive.

4. Research, Development, and Innovation. Provide incentives for startups, universities, and industries to work together and build.

5. Regulatory and Ethical Frameworks. Create clear rules so AI remains secure, fair, and aligned with public values.

6. International Cooperation. Sovereignty doesn’t mean isolation. Smart partnerships and shared standards matter.

The Fine Line: Sovereignty Without Isolation

Some warn that countries could end up with “AI islands” — local models and tools that fall behind because they’re cut off from global advances. It’s a valid concern. The real challenge is building local resilience while staying connected to global innovation. The EU’s Gaia-X, ASEAN’s shared AI cloud, and public-private partnerships with hyperscalers are examples of how countries hedge against stagnation.

The lesson is clear: relying indefinitely on black-box systems you don’t control carries real costs. Dependence will only get more expensive.

What Happens Next

Countries that get this right won’t just survive the next wave of disruption — they’ll shape it. They’ll become creators, not just consumers. Productivity gains from AI will stay at home instead of drifting off to foreign shareholders. And they’ll maintain cultural and democratic oversight of the systems that increasingly shape daily life.

In the digital age, sovereignty isn’t about closing doors; it’s about having leverage. It means having the talent and infrastructure to choose your partners on your own terms — and to stand independently when it matters.

In the AI era, that’s no longer a luxury. It’s the new baseline for trust, prosperity, and national resilience.