Jensen Huang at Goldman Sachs: AI Is a Fundamental Computing Paradigm Shift, $4T Infrastructure Vision, Supply Chain Bottlenecks Through 2028
Jensen Huang at Goldman Sachs: AI Is a Fundamental Computing Paradigm Shift, $4T Infrastructure Vision, Supply Chain Bottlenecks Through 2028
1. Introduction: The San Francisco Podium That Defined an Era
On September 10, 2026, Jensen Huang walked onto the stage of the Goldman Sachs Communacopia + Technology Conference in San Francisco wearing his signature black leather jacket. This was not another technical keynote at SIGGRAPH or GTC — this was a “judgment day” address to Wall Street and the global technology industry.
Over a 90-minute conversation, Huang delivered a systematic diagnosis across four dimensions: a fundamental paradigm shift in computing, the scale of AI infrastructure investment, multi-layered supply chain constraints, and an inflection point for embodied intelligence. These judgments not only define NVIDIA’s strategic position but also map out the trajectory of the entire AI industry through 2030.
This article provides a deep technical analysis of these core arguments — examining them through the lens of computational principles, economic models, code implementations, and industrial dynamics.
2. From Retrieval to Generation: The Fundamental Computing Paradigm Shift
2.1 Huang’s Core Thesis
Huang made his position unequivocal:
“AI is not another ordinary technology cycle — it is a fundamental shift in computing from retrieval-based to generation-based.”
This statement draws a sharp line between the current AI wave and every previous technology cycle. The traditional computing paradigm is characterized by retrieval — users fetch existing information from databases, search engines, and file systems. Generative AI, by contrast, means systems actively produce new content, solutions, and decisions on demand.
2.2 Retrieval vs. Generation: Architectural Divergence
To understand the depth of this transformation, we must examine the fundamental architectural differences.
┌─────────────────────────────────────────────────────────────┐
│ Three Eras of Computing Paradigms │
├─────────────────┬─────────────────┬──────────────────────────┤
│ Era │ Core Operation │ Representative Systems │
├─────────────────┼─────────────────┼──────────────────────────┤
│ Computing 1.0 │ Compute │ CPU + von Neumann arch │
│ (1950-2000) │ │ Excel / ERP / Databases │
├─────────────────┼─────────────────┼──────────────────────────┤
│ Computing 2.0 │ Retrieve │ CPU + Index + Sort │
│ (2000-2020) │ │ Google / MySQL / CDN │
├─────────────────┼─────────────────┼──────────────────────────┤
│ Computing 3.0 │ Generate │ GPU + Transformer │
│ (2020-) │ │ GPT / Diffusion / RL │
└─────────────────┴─────────────────┴──────────────────────────┘
The fundamental bottleneck of retrieval-based systems: you can only find information that already exists. Generative systems break this constraint — they can create content during inference that never appeared in its complete form in the training data.
2.3 Code Practice: Simulating Throughput Differences in Go
// paradigm_comparison.go
// Simulating throughput comparison between retrieval and generative paradigms
package main
import (
"fmt"
"math"
)
type RetrievalSystem struct {
cacheSize int
latencyNS float64
}
type GenerativeSystem struct {
paramsCount float64
computePerToken float64
}
func (r *RetrievalSystem) Throughput(concurrency int) float64 {
return float64(concurrency) / (r.latencyNS * 1e-9)
}
func (g *GenerativeSystem) Throughput(concurrency int, batchSize int, outputTokens int) float64 {
flopsPerToken := 2.0 * g.paramsCount * 1e9
totalFlops := flopsPerToken * float64(outputTokens) * float64(batchSize)
h100Peak := 1979.0 * 1e12
utilization := 0.45
effectiveFlops := h100Peak * utilization
latencyMs := (totalFlops / effectiveFlops) * 1000
return float64(concurrency) * (float64(outputTokens) / (latencyMs / 1000.0))
}
func main() {
retrieval := &RetrievalSystem{cacheSize: 100_000_000, latencyNS: 500_000}
generative := &GenerativeSystem{paramsCount: 70.0, computePerToken: 140.0e9}
fmt.Println("=== Computing Paradigm Throughput Comparison ===")
fmt.Printf("Retrieval (10 concurrent): %.2f queries/s\n", retrieval.Throughput(10))
fmt.Printf("Retrieval (100 concurrent): %.2f queries/s\n", retrieval.Throughput(100))
fmt.Printf("Retrieval (1000 concurrent): %.2f queries/s\n", retrieval.Throughput(1000))
for _, batch := range []int{1, 4, 16} {
tput := generative.Throughput(1, batch, 1024)
fmt.Printf("Generative (70B, batch=%d, 1024 tokens): %.2f tokens/s\n", batch, tput)
}
fmt.Println("\n=== Key Insights ===")
fmt.Println("Retrieval: deterministic latency, horizontally scalable, produces no new knowledge")
fmt.Println("Generative: compute-intensive, latency grows with output, creates novel content")
fmt.Println("The paradigm shift: from 'searching known' to 'generating unknown'")
// Compute GPU count needed for 1 trillion tokens/day
dailyTokens := 1e12
flopsPerToken := 2.0 * generative.paramsCount * 1e9
totalDailyFlops := dailyTokens * flopsPerToken
h100Count := totalDailyFlops / (1979e12 * 3600 * 24 * 0.45)
fmt.Printf("\nH100 GPUs needed for 1T tokens/day: %.0f\n", math.Ceil(h100Count))
fmt.Printf("Equivalent Blackwell GPUs (2x perf): %.0f\n", math.Ceil(h100Count/2))
}
The simulation reveals a stark reality: retrieval systems can easily achieve hundreds of thousands of queries per second, while generative systems, under the same hardware budget, produce tokens at rates orders of magnitude lower. This explains why AI infrastructure investment must reach trillions of dollars — generative computing consumes compute power exponentially.
3. AI Factories: The Economics of a New Asset Class
3.1 From GPU Chips to AI Factories
Huang introduced a crucial conceptual shift: the AI Factory is becoming a new asset class that produces intelligence.
Traditional general-purpose data centers are built around CPU servers running diverse workloads. AI factories, by contrast, center on massive GPU clusters with high-speed networking (NVLink + InfiniBand) and high-power electrical infrastructure. Their sole output: intelligent tokens.
┌──────────────────────────────────────────────────────────────┐
│ Traditional Data Center vs. AI Factory: Comparison │
├────────────────────────┬─────────────────────────────────────┤
│ Traditional DC │ AI Factory │
├────────────────────────┼─────────────────────────────────────┤
│ CPU server clusters │ GPU clusters (H100/B200/Rubin) │
│ General compute+store │ Dedicated AI inference + training │
│ Gigabit/10GbE │ NVLink + InfiniBand (800Gbps+) │
│ 5-10 kW/rack │ 40-100+ kW/rack (liquid cooled) │
│ PUE 1.4-1.6 │ PUE 1.1-1.2 (liquid cooling opt.) │
│ Output: CPU cycles+I/O│ Output: Tokens/second │
│ Cost center │ Profit center (tokens = revenue) │
│ General software │ CUDA + distributed frameworks │
│ Low power density │ Extremely high power density │
└────────────────────────┴─────────────────────────────────────┘
3.2 Token Economics of AI Factories
Huang’s analogy of AI factories as “power plants” — electrons in, tokens out — maps to a complete economic model:
# ai_factory_economics.py
# AI Factory economic model: from chip cost to token pricing
def ai_factory_unit_economics(
gpu_count: int,
gpu_unit_cost: float,
power_per_gpu_kw: float,
electricity_cost: float,
cluster_life_years: int,
utilization: float,
tokens_per_gpu_per_sec: float,
cooling_overhead: float = 1.3,
facility_cost_factor: float = 0.3,
opex_pct_capex: float = 0.08,
) -> dict:
# Capital expenditure
gpu_capex = gpu_count * gpu_unit_cost
network_capex = gpu_capex * 0.15
facility_capex = gpu_capex * facility_cost_factor
total_capex = gpu_capex + network_capex + facility_capex
annual_depreciation = total_capex / cluster_life_years
# Operating expenditure
total_power_mw = gpu_count * power_per_gpu_kw * cooling_overhead / 1000
annual_power_cost = total_power_mw * 1000 * 24 * 365 * electricity_cost
annual_opex = total_capex * opex_pct_capex
total_annual_cost = annual_depreciation + annual_power_cost + annual_opex
# Token production
annual_tokens = gpu_count * tokens_per_gpu_per_sec * 3600 * 24 * 365 * utilization
cost_per_million_tokens = (total_annual_cost / annual_tokens) * 1_000_000
return {
"total_capex": total_capex,
"annual_cost": total_annual_cost,
"annual_power_cost": annual_power_cost,
"annual_tokens": annual_tokens,
"cost_per_million_tokens": cost_per_million_tokens,
"total_power_mw": total_power_mw,
"cost_breakdown": {
"depreciation_pct": annual_depreciation / total_annual_cost * 100,
"power_pct": annual_power_cost / total_annual_cost * 100,
"opex_pct": annual_opex / total_annual_cost * 100,
}
}
# Scenario A: 100K H100 cluster
result_a = ai_factory_unit_economics(100_000, 30_000, 0.7, 0.08, 5, 0.65, 100)
# Scenario B: 50K Blackwell cluster
result_b = ai_factory_unit_economics(50_000, 35_000, 1.0, 0.08, 5, 0.70, 300)
# Scenario C: 1M GPU (1GW) supercluster
result_c = ai_factory_unit_economics(1_000_000, 25_000, 0.8, 0.06, 6, 0.75, 500)
for name, r in [("100K H100s", result_a), ("50K Blackwells", result_b), ("1M Rubins (1GW)", result_c)]:
print(f"\n=== {name} ===")
print(f" Total Capex: ${r['total_capex']/1e9:.2f}B")
print(f" Annual cost: ${r['annual_cost']/1e9:.2f}B")
print(f" Annual power: ${r['annual_power_cost']/1e6:.0f}M")
print(f" Power draw: {r['total_power_mw']:.0f} MW")
print(f" Annual tokens: {r['annual_tokens']/1e15:.2f} quadrillion")
print(f" Cost/M tokens: ${r['cost_per_million_tokens']:.2f}")
print(f" Cost structure: Depreciation {r['cost_breakdown']['depreciation_pct']:.1f}% / "
f"Power {r['cost_breakdown']['power_pct']:.1f}% / "
f"Opex {r['cost_breakdown']['opex_pct']:.1f}%")
This model reveals the central tension of AI factory economics: power costs rise as a percentage of total operating costs with cluster scale. For 1GW-class AI factories, electricity can represent 40-50% of total operational expenditure. This is precisely why Huang emphasized “land, electricity, and data center shells” as the primary downstream constraints.
3.3 The Five-Layer Cake of AI Infrastructure
Huang described AI infrastructure as a “five-layer cake”:
┌─────────────────────────────────┐
│ Applications │ ← ChatGPT, Copilot, Security tools
├─────────────────────────────────┤
│ Models │ ← GPT-5, Gemini, Llama, Nemotron
├─────────────────────────────────┤
│ Physical Infrastructure │ ← Data centers, liquid cooling, racks
├─────────────────────────────────┤
│ Chips │ ← GPU, HBM, NVLink, Networking
├─────────────────────────────────┤
│ Energy │ ← Grid, nuclear, natural gas peaking
└─────────────────────────────────┘
"The constraint is not software, but watts."
This reframes AI’s growth bottleneck from a technology problem to an energy and physical infrastructure problem.
4. The $4 Trillion Prediction: Deconstructing AI Infrastructure Investment Through 2030
4.1 The Logic Behind the Numbers
Huang reaffirmed that by 2030, global annual AI infrastructure spending will reach $3 trillion to $4 trillion. This encompasses:
- Chips/accelerators: GPUs, ASICs, HBM, networking silicon
- Servers/racks: Complete systems, NVLink interconnects, liquid cooling
- Networking: InfiniBand, Ethernet, optical transceivers
- Data center construction: Buildings, cooling, power distribution, UPS
- Power infrastructure: Substations, transmission lines, backup generation
The capital flow structure can be visualized as follows:
┌──────────────────────────────────────────────────────────────┐
│ $4T Annual AI Investment: Capital Flow Structure │
├──────────────────────────────────────────────────────────────┤
│ ┌─────────────────────┐ │
│ │ GPU/HBM Chips │ │
│ │ $1.2T (30%) │ │
│ └──────────┬──────────┘ │
│ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Servers/ │ │ Networking │ │ Data Center │ │
│ │ Racks │◄──►│ Equipment │◄──►│ Construction│ │
│ │ $0.6T (15%) │ │ $0.3T (7.5%)│ │ $0.6T (15%) │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ ▼ │
│ ▼ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Power Infrastructure: substations, transmission │ │
│ │ lines, backup power $0.5T (12.5%) │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Cooling: liquid, air, heat recovery $0.2T (5%) │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ Software/Platform: CUDA, frameworks, security │ │
│ │ $0.1T (2.5%) │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ DRAM/HBM Memory: $0.5T (12.5%) │ │
│ └──────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
4.2 Historical Comparison
// capex_comparison.go
// Historical infrastructure investment comparison
package main
import "fmt"
type InfrastructureEra struct {
name string
era string
peakAnnualCapex float64 // Trillions USD (2026-adjusted)
durationYears int
}
func main() {
eras := []InfrastructureEra{
{"Railroad", "1860-1890", 0.08, 30},
{"Electrification", "1910-1940", 0.12, 30},
{"Interstate Highways", "1956-1980", 0.06, 24},
{"Internet Backbone", "1995-2005", 0.35, 10},
{"Mobile (4G/5G)", "2010-2025", 0.50, 15},
{"AI Infrastructure (fct)", "2024-2030", 3.50, 7},
}
fmt.Println("=== Historical Infrastructure Investment Comparison ===")
for _, e := range eras {
fmt.Printf("%-25s %-18s $%.2fT %d yrs\n",
e.name, "("+e.era+")", e.peakAnnualCapex, e.durationYears)
}
fmt.Println("\nAI peak annual investment is 10x the Internet era")
fmt.Println("AI peak annual investment is 7x the Mobile era")
fmt.Println("Cumulative AI investment over 7 years: ~$24.5T")
// Investment breakdown
fmt.Println("\n=== Breakdown of $4T Annual AI Capex ===")
categories := []struct {
name string
value float64
}{
{"GPU/Accelerator chips", 1.20},
{"HBM/DRAM memory", 0.50},
{"Server/rack systems", 0.60},
{"Networking", 0.30},
{"Data center construction", 0.60},
{"Power infrastructure", 0.50},
{"Cooling systems", 0.20},
{"Software/platform", 0.10},
}
total := 0.0
for _, c := range categories {
total += c.value
}
for _, c := range categories {
fmt.Printf(" %-25s $%.2fT (%5.1f%%)\n", c.name, c.value, c.value/total*100)
}
fmt.Printf(" %-25s $%.2fT (100%%)\n", "Total", total)
factoryCost := 50.0 // $50B per 1GW AI factory
factoryCount := total / (factoryCost / 1000)
fmt.Printf("\nEquivalent 1GW AI factories: %.0f\n", factoryCount*1000/factoryCost)
}
4.3 Real-World Validation
Huang’s data points have concrete real-world counterparts:
- Microsoft’s 38GW portfolio: Microsoft has signed long-term power purchase agreements totaling approximately 38GW — equivalent to 38 nuclear power plants
- Philippines $34B AI infrastructure: The Philippine government announced a $34 billion AI infrastructure plan focusing on data center campuses and submarine cables
- Australia’s 2GW/$80B plan: Huang disclosed that NVIDIA is working with Australian data center operators on plans involving 2GW of capacity for 2027, valued at approximately $80 billion
These cases validate Huang’s core thesis: AI infrastructure is evolving from technology company capex into national-level infrastructure investment.
5. Supply Chain Bottlenecks Through 2028: The Quadruple Constraint
5.1 Upstream: Advanced Packaging and HBM Memory
Huang candidly acknowledged that NVIDIA faces multiple supply chain challenges. On the upstream side: advanced packaging (CoWoS/SiPh), HBM/DRAM memory, connectors, voltage regulators, and wafer capacity are all under pressure.
The most strategic bottleneck is HBM (High Bandwidth Memory). NVIDIA disclosed that its memory procurement commitments more than doubled in a single quarter — from approximately $119 billion to $279 billion. This is the strongest signal of NVIDIA’s confidence in durable AI demand, but it also brings margin pressure — from ~75% currently to a projected trough of 71-72%.
# supply_chain_bottleneck.py
# AI supply chain bottleneck model
def compute_bottleneck_impact(
hbm_supply_gb: float,
hbm_per_gpu_gb: float,
gpu_demand: int,
cowos_capacity: int,
gpu_per_wafer: float,
power_available_mw: int,
power_per_cluster_mw: float,
site_land_available: int,
) -> dict:
hbm_constrained = int(hbm_supply_gb / hbm_per_gpu_gb)
hbm_util = min(1.0, hbm_supply_gb / (gpu_demand * hbm_per_gpu_gb))
cowos_gpus = cowos_capacity * gpu_per_wafer
cowos_util = min(1.0, cowos_gpus / gpu_demand)
power_gpus = (power_available_mw / power_per_cluster_mw) * 100_000
power_util = min(1.0, power_gpus / gpu_demand)
site_gpus = site_land_available * 100_000
site_util = min(1.0, site_gpus / gpu_demand)
effective = min(hbm_constrained, int(cowos_gpus), int(power_gpus), int(site_gpus))
unmet = (1 - effective / gpu_demand) * 100
constraints = {
"HBM": hbm_util, "CoWoS": cowos_util,
"Power": power_util, "Site": site_util,
}
primary = min(constraints, key=constraints.get)
return {
"effective_gpus": effective,
"unmet_demand_pct": unmet,
"constraints": constraints,
"primary_bottleneck": primary,
}
# 2026 scenario
r26 = compute_bottleneck_impact(45_000_000, 144, 4_000_000, 450_000, 6, 20_000, 100, 80)
# 2028 scenario (partial relief)
r28 = compute_bottleneck_impact(120_000_000, 288, 10_000_000, 900_000, 4, 50_000, 200, 200)
for year, r in [("2026", r26), ("2028", r28)]:
print(f"\n=== {year} Supply Analysis ===")
print(f"Effective GPUs: {r['effective_gpus']:,}")
print(f"Unmet demand: {r['unmet_demand_pct']:.1f}%")
print(f"Primary bottleneck: {r['primary_bottleneck']}")
for k, v in r['constraints'].items():
print(f" {k}: {v*100:.1f}%")
5.2 Downstream: Land, Power, and Data Centers
Huang’s downstream challenges are perhaps more intractable: land acquisition, power supply, and “data center shells” (buildings without computing equipment) are becoming longer-term constraints.
Goldman Sachs’ trading desk estimates that constraints around power, memory, data center construction, and capacity could leave AI compute supply in deficit through 2028. The entire AI industry will likely remain in a state where “finding power is harder than finding chips” for the next 2-3 years.
5.3 NVIDIA’s Response: The World’s Largest Supply Network
Facing these constraints, Huang showcased NVIDIA’s “largest upstream supply chain network” and “diversified downstream channels”. The full value chain from wafers to tokens can be visualized as:
┌─────────────────────────────────────────────────────────────────────┐
│ AI Supply Chain Ecosystem: From Wafer to Token │
├────────────┬───────────────────┬────────────────┬───────────────────┤
│ Upstream │ Midstream │ Downstream │ End Applications │
│ (Chips) │ (Systems) │ (IaaS) │ (AI Services) │
├────────────┼───────────────────┼────────────────┼───────────────────┤
│ TSMC │ Dell │ Microsoft Azure│ OpenAI │
│ (3nm/CoWoS)│ Supermicro │ Google Cloud │ Anthropic │
│ │ │ │ │
│ SK Hynix │ Lenovo │ AWS │ Meta │
│ (HBM4) │ HP │ │ │
│ │ │ CoreWeave │ xAI │
│ Samsung │ Quanta/Wistron │ Nebius │ (Model companies) │
│ (DRAM/HBM) │ (ODM) │ Lambda │ │
│ │ │ Firmus │ Enterprise clients│
│ Amphenol │ │ (Neoclouds) │ (security/health/ │
│ (connectors)│ │ │ finance) │
│ │ │ Sovereign AI │ │
│ Delta │ │ (National │ Reasoning Robots │
│ (power) │ │ projects) │ (~2yr inflection) │
└────────────┴───────────────────┴────────────────┴───────────────────┘
↑ ↑ ↑
Packaging, HBM, wafers System integr., Land, power,
(primary bottleneck now) liquid cooling data center shells
(easing) (constrained through 2028)
Specifically:
- Upstream: TSMC (advanced node + CoWoS), Samsung/SK Hynix (HBM/DRAM), Amphenol/Delta (connectors/power)
- Midstream: Dell, Supermicro, Lenovo, HP (system integration)
- Downstream: CoreWeave, Nebius, Lambda, Firmus (Neoclouds) + Microsoft/Google/Amazon (Hyperscalers)
6. The Reasoning Robot Inflection Point: From LLMs to Embodied Intelligence
6.1 Huang’s Timeline
Huang predicted that reasoning-based robotic manipulation technology will reach a major inflection point in approximately two years. Reasoning robots leverage LLM inference capabilities for environmental perception, task planning, and action execution in unstructured environments.
6.2 From Language Models to the Physical World
┌──────────────────────────────────────────────────────────────────┐
│ Embodied Intelligence Roadmap: From LLM to Reasoning Robot │
├──────────┬────────────────┬────────────────┬────────────────────┤
│ Phase │ Current │ ~2 years │ ~5 years │
│ │ (2026) │ (2028) │ (2031) │
├──────────┼────────────────┼────────────────┼────────────────────┤
│Perception│ VLM + 2D │ Real-time 3D │ Autonomous env. │
│ │ detection │ semantic + │ modeling + │
│ │ │ tactile fusion │ causal reasoning │
├──────────┼────────────────┼────────────────┼────────────────────┤
│Planning │ Pre-set │ LLM autonomous │ End-to-end │
│ │ policies + │ planning + │ learning + │
│ │ behavior trees│ physics sim │ meta-learning │
├──────────┼────────────────┼────────────────┼────────────────────┤
│Execution │ Imitation │ RL + imitation │ Autonomous skill │
│ │ + teleop │ learning fusion│ acquisition + tool│
├──────────┼────────────────┼────────────────┼────────────────────┤
│Deployment│ Lab demos │ Limited domain │ Large-scale │
│ │ │ pilots │ commercial │
└──────────┴────────────────┴────────────────┴────────────────────┘
6.3 Code Practice: The Robot Reasoning Software Stack
# robot_reasoning_stack.py
# Reasoning-based robot control architecture simulation
import math
from typing import List, Tuple
class PerceptionModule:
"""Perception: VLM-driven semantic understanding"""
def detect_objects(self, robot_pos: Tuple[float, float],
obstacles: List, targets: List) -> List[dict]:
detections = []
for ox, oy, r in obstacles:
dist = math.sqrt((ox - robot_pos[0])**2 + (oy - robot_pos[1])**2)
confidence = max(0.3, 1.0 - dist / 10.0)
if confidence >= 0.85:
detections.append({
"type": "obstacle", "position": (ox, oy),
"radius": r, "confidence": round(confidence, 3)
})
for tx, ty, label in targets:
dist = math.sqrt((tx - robot_pos[0])**2 + (ty - robot_pos[1])**2)
confidence = max(0.5, 1.0 - dist / 15.0)
if confidence >= 0.85:
detections.append({
"type": "target", "position": (tx, ty),
"semantic_label": label, "confidence": round(confidence, 3)
})
return detections
class ReasoningPlanner:
"""Planning: LLM-based task and path planning"""
def plan_path(self, robot_pos: Tuple[float, float],
target: Tuple[float, float],
obstacles: List[Tuple[float, float, float]]) -> List[Tuple[float, float]]:
dx = target[0] - robot_pos[0]
dy = target[1] - robot_pos[1]
print(f"[Planning] Position: {robot_pos}, Target: {target}")
print(f"[Planning] Obstacles: {len(obstacles)}")
path_blocked = False
for ox, oy, r in obstacles:
t = max(0, min(1, ((ox - robot_pos[0])*dx + (oy - robot_pos[1])*dy) /
(dx**2 + dy**2 + 0.001)))
closest_x = robot_pos[0] + t * dx
closest_y = robot_pos[1] + t * dy
dist = math.sqrt((closest_x - ox)**2 + (closest_y - oy)**2)
if dist < r + 0.3:
path_blocked = True
break
if path_blocked:
angle = math.atan2(dy, dx)
perp = angle + math.pi / 2
closest_obs = min(obstacles,
key=lambda o: math.sqrt((o[0]-robot_pos[0])**2 + (o[1]-robot_pos[1])**2))
bypass = closest_obs[2] + 1.0
wp1 = (robot_pos[0] + math.cos(angle)*2 + math.cos(perp)*bypass,
robot_pos[1] + math.sin(angle)*2 + math.sin(perp)*bypass)
wp2 = (target[0] - math.cos(angle)*2 + math.cos(perp)*bypass,
target[1] - math.sin(angle)*2 + math.sin(perp)*bypass)
return [robot_pos, wp1, wp2, target]
return [robot_pos, target]
class MotionController:
"""Execution: converting plans to motor commands"""
def __init__(self):
self.position = (0.0, 0.0)
def execute_path(self, waypoints: List[Tuple[float, float]],
max_speed: float = 1.0, dt: float = 0.1) -> List[Tuple[float, float]]:
trajectory = [waypoints[0]]
current = waypoints[0]
for target in waypoints[1:]:
dx = target[0] - current[0]
dy = target[1] - current[1]
dist = math.sqrt(dx**2 + dy**2)
steps = int(dist / (max_speed * dt))
for i in range(1, steps + 1):
t = i / steps
trajectory.append((current[0] + dx * t, current[1] + dy * t))
current = target
self.position = current
return trajectory
def run_robot_demo():
print("=" * 60)
print("Reasoning Robot Operation Simulation")
print("=" * 60)
robot_start = (1.0, 1.0)
obstacles = [(3.0, 3.0, 0.5), (5.0, 6.0, 0.8)]
target_pos = (8.0, 2.0)
perception = PerceptionModule()
detections = perception.detect_objects(robot_start, obstacles, [(8.0, 2.0, "parts bin")])
print(f"\n[Step 1] Detected {len(detections)} objects")
planner = ReasoningPlanner()
waypoints = planner.plan_path(robot_start, target_pos, obstacles)
controller = MotionController()
trajectory = controller.execute_path(waypoints)
print(f"\n[Step 3] Execution complete")
print(f"Final position: {controller.position}")
print(f"Trajectory points: {len(trajectory)}")
print(f"Task: {'✅ Success' if controller.position == target_pos else '❌ Failed'}")
print("\n" + "=" * 60)
print("Key Conclusions: Reasoning Robot Capability Stack")
print("1. Perception: VLM converts visual input to structured semantics")
print("2. Planning: LLM performs causal reasoning in unstructured env.")
print("3. Execution: Translates high-level decisions to motor control")
print("4. Bottleneck: Real-time latency (end-to-end <100ms required)")
print("=" * 60)
run_robot_demo()
7. Industrial Chain Reactions: From AI Companies to Power Infrastructure
7.1 Cybersecurity: AI Creates Its Own Demand
Huang highlighted cybersecurity’s strategic position: “What better way to create demand than to create a problem?” He explicitly noted that while AI automates programming, it simultaneously accelerates the speed at which vulnerabilities are discovered, exploited, and patched. Cybersecurity thus becomes a “self-generated demand source” for AI.
The SafeMind system jointly launched by NVIDIA and CrowdStrike, built on Nemotron models, employs a dual-agent “offense-defense” architecture — Blue Solano (defensive) and Red Tempest (offensive) continuously compete in a digital twin environment. This effectively creates a never-saturating inference demand market.
7.2 Hyperscaler Challenges
Goldman Sachs’ trading desk identified the core market debate: whether AI capital expenditure can translate into sustained profitable growth. Two key concerns:
- Backlog conversion: Hyperscalers need to convert their order backlogs into sustained enterprise AI revenue
- Token optimization: Customers are shifting from maximizing token usage to ROI-driven “token optimization” — flexibly selecting models based on task requirements
7.3 The Circular Financing Debate
Addressing concerns about “circular financing” — NVIDIA investing in companies that then buy its products — Huang responded directly:
“We put in $1 and $100 comes back. Is that circular? If so, give me more.”
He emphasized that NVIDIA confirms real customer contracts before investing, and has seen such contracts totaling $100 billion. The $500 billion AI infrastructure financing platform with Apollo, BlackRock, Blackstone, Goldman Sachs, and KKR further positions AI factories as a financeable asset class.
8. Outlook: When Compute Becomes a Commodity
8.1 The Evolution of AI Factory Economics
Huang’s speech outlines a clear evolutionary path:
┌──────────────────────────────────────────────────────────────┐
│ NVIDIA Business Model Evolution │
├──────────┬───────────────┬──────────────┬─────────────────────┤
│ Phase │ GPU Sales │ System Sales │ Inference as Service │
│ │ (2010-2020) │ (2020-2026) │ (2026-2030) │
├──────────┼───────────────┼──────────────┼─────────────────────┤
│ Product │ Single GPU │ DGX/NVL racks│ AI factory turnkey │
│ Pricing │ $399-$30K │ $200K-$3M │ $50B-$100B/GW │
│ Customer │ Gamers/research│ Cloud/enterprise │ Sovereign/funds │
│ Metric │ FLOPS/watt │ System throughput │ Tokens/watt │
│ Margin │ 60%+ │ 75% │ TBD │
└──────────┴───────────────┴──────────────┴─────────────────────┘
8.2 The “Growth Value Stock” Thesis
Huang called NVIDIA “the world’s first and only growth value stock.” This rests on two pillars:
- Growth: 70% YoY revenue guidance, with unconstrained demand exceeding 100%
- Value: 75% gross margins, $300B+ trailing twelve-month revenue, and the shift from “chip transactions” to “energy and campus bundling”
8.3 Core Conclusions
Synthesizing Huang’s Goldman Sachs address yields seven core conclusions:
- AI is not another technology cycle — it is a fundamental shift in computing paradigm, from retrieval to generation
- Investment scale is unprecedented — $3-4 trillion annual spend by 2030, exceeding any previous infrastructure wave
- Supply bottlenecks are physical — not a demand problem, but constraints in packaging, memory, power, and land
- Robot inflection is imminent — reasoning-based embodied intelligence reaches a qualitative change in ~2 years
- Cybersecurity is AI’s self-generated demand — the more powerful AI becomes, the more urgent AI security grows
- Compute is becoming a basic commodity — like electricity, intelligent tokens will be measured and traded in “tokens/watt”
When Huang says “every piece of land and every watt of power on Earth is within our field of view,” he is effectively declaring that NVIDIA has transformed from a chip company into the operating system of global AI infrastructure.
And the Goldman Sachs Communacopia + Technology Conference stage was the manifesto for this new era.
This article is based on Jensen Huang’s address at the Goldman Sachs Communacopia + Technology Conference on September 10, 2026.