Meta Iris AI Chip: Broadcom + TSMC, September Mass Production, 7GW→14GW Capacity Doubling Strategy Deep Dive

Meta Iris AI Chip: Broadcom + TSMC, September Mass Production, 7GW→14GW Capacity Doubling Strategy Deep Dive

1. Introduction

In July 2026, Reuters disclosed Meta’s internal memo: the codenamed “Iris” self-developed AI chip is scheduled for mass production in September. Designed by Meta, co-developed with Broadcom, and manufactured by TSMC, the chip passed 6 weeks of testing with no major issues. Meta also announced aggressive capacity expansion plans—7GW in 2026, doubling to 14GW in 2027, with $145 billion in capital expenditure.

This is not a “Meta dumps NVIDIA” signal. The memo explicitly states Iris “complements rather than replaces” NVIDIA GPUs. Meta secured multi-year supply agreements with Samsung Electronics (memory), SanDisk (flash storage), and Sumitomo Electric (fiber optics), building a dual-track “self-developed + external procurement” infrastructure.

2. Iris Chip: MTIA Fourth Generation

2.1 MTIA Roadmap

GenerationCodenameCapabilityStatus
MTIA v1—First-gen inference2024 deployed
MTIA v2—Inference + training2025 deployed
MTIA v3—Inference optimizationInternal testing
MTIA v4IrisInference + training + scaleSep 2026 mass production

2.2 Iris Architecture

from dataclasses import dataclass

@dataclass
class IrisSpec:
    process_node: str = "3nm"  # TSMC N3
    transistor_count: int = 120_000_000_000
    tensor_cores: int = 4096
    hbm_capacity_gb: int = 128
    hbm_bandwidth_tbps: float = 3.5
    sram_capacity_mb: int = 256
    tdp_watts: int = 700
    peak_performance_tflops: float = 450
    sparse_support: bool = True
    moe_optimized: bool = True

class IrisComputeUnit:
    def __init__(self, spec: IrisSpec):
        self.spec = spec
    
    def estimate_inference_throughput(self, model_size_params, batch_size=1, precision=8, seq_len=4096):
        flops_per_token = 2 * model_size_params * (precision / 8)
        total_flops = flops_per_token * seq_len * batch_size
        
        effective_compute = self.spec.peak_performance_tflops * 1e12
        if self.spec.sparse_support:
            effective_compute *= 2.0
        
        model_size_bytes = model_size_params * (precision / 8)
        kv_cache_bytes = seq_len * 8192 * 2 * 80 * 2 * 2
        total_memory_read = (model_size_bytes + kv_cache_bytes) * batch_size
        bandwidth = self.spec.hbm_bandwidth_tbps * 1e12 / 8
        memory_bound = total_memory_read / bandwidth
        compute_bound = total_flops / effective_compute
        actual_latency = max(compute_bound, memory_bound)
        throughput = batch_size / actual_latency
        
        return {
            "throughput_tokens_per_sec": throughput,
            "latency_ms": actual_latency * 1000,
            "compute_utilization": compute_bound / actual_latency * 100,
            "power_watts": self.spec.tdp_watts * (0.3 + 0.7 * compute_bound / actual_latency),
        }

spec = IrisSpec()
compute = IrisComputeUnit(spec)
result = compute.estimate_inference_throughput(10_000_000_000, 32, 8, 1024)
print(f"Throughput: {result['throughput_tokens_per_sec']:.0f} tok/s")
print(f"Latency: {result['latency_ms']:.1f}ms")
print(f"Utilization: {result['compute_utilization']:.0f}%")

3. Capacity Expansion: 7GW→14GW

7GW is equivalent to about 7 large nuclear power plants. Meta plans to deploy 7GW by end of 2026 and double to 14GW by 2027.

package main

import "fmt"

type CapacityPlan struct {
    Year    int
    TotalGW float64
    GPUShare  float64
    IrisShare float64
}

func NewCapacityPlan(year int, totalGW float64) *CapacityPlan {
    p := &CapacityPlan{Year: year, TotalGW: totalGW, TotalMW: totalGW * 1000}
    if year == 2026 { p.GPUShare, p.IrisShare = 0.70, 0.30 }
    else { p.GPUShare, p.IrisShare = 0.55, 0.45 }
    return p
}

func (p *CapacityPlan) CalculateSavings(gpuCost, irisCost float64, dailyTokens int64) float64 {
    total := float64(dailyTokens)
    gpuT := total * p.GPUShare
    irisT := total * p.IrisShare
    allGPU := total * gpuCost
    actual := gpuT*gpuCost + irisT*irisCost
    return (allGPU - actual) * 365
}

func main() {
    p2027 := NewCapacityPlan(2027, 14)
    saving := p2027.CalculateSavings(0.000003, 0.000001, 50_000_000_000_000)
    fmt.Printf("2027 annual saving: $%.2fB\n", saving/1e9)
}

4. The “Complement, Not Replace” Strategy

Meta’s strategy has three layers:

  1. Risk diversification: Iris failure → NVIDIA backup; NVIDIA shortage → Iris supplement
  2. Cost optimization: Iris for daily inference (recommendation, search, content moderation); NVIDIA for large-scale training
  3. Supply chain autonomy: New chip every 6 months → gradual self-sufficiency increase

4.1 Hybrid Inference Scheduler

import numpy as np
from enum import Enum
from dataclasses import dataclass

class ChipType(Enum):
    NVIDIA_GPU = "nvidia"
    META_IRIS = "iris"

@dataclass
class Task:
    task_id: str
    task_type: str  # inference, training, recommendation, search
    model_size_b: float
    latency_sla_ms: float

class HybridScheduler:
    def __init__(self, iris_count=100, gpu_count=100):
        self.iris = [{"id": f"iris-{i}", "load": 0.0} for i in range(iris_count)]
        self.gpu = [{"id": f"gpu-{i}", "load": 0.0} for i in range(gpu_count)]
        self.metrics = {"iris": 0, "gpu": 0, "cost": 0.0}
    
    def schedule(self, task):
        # Iris cost ~40% of GPU
        cost_per_token = {ChipType.NVIDIA_GPU: 3e-6, ChipType.META_IRIS: 1.2e-6}
        
        # Routing logic
        if task.task_type == "training":
            chip_type = ChipType.NVIDIA_GPU
        elif task.task_type in ("inference", "recommendation", "search"):
            # Prefer Iris for inference tasks
            chip_type = ChipType.META_IRIS
        else:
            chip_type = ChipType.META_IRIS
        
        pool = self.iris if chip_type == ChipType.META_IRIS else self.gpu
        # Find least loaded chip
        chip = min(pool, key=lambda c: c["load"])
        chip["load"] = min(1.0, chip["load"] + 0.1)
        
        tokens = task.model_size_b * 1000
        cost = tokens * cost_per_token[chip_type]
        self.metrics["cost"] += cost
        self.metrics[chip_type.value] += 1
        
        return {"chip": chip["id"], "type": chip_type.value, "cost": cost}

# Simulation
scheduler = HybridScheduler()
tasks = []
for i in range(1000):
    ttype = np.random.choice(["inference", "recommendation", "training", "search"], 
                             p=[0.3, 0.3, 0.2, 0.2])
    tasks.append(Task(f"t-{i}", ttype, np.random.choice([1,3,7,13,70,175]), 
                     np.random.choice([50,100,200,500])))

for t in tasks:
    scheduler.schedule(t)

m = scheduler.metrics
total = m["iris"] + m["gpu"]
print(f"Total tasks: {total}")
print(f"Iris share: {m['iris']/total:.1%}")
print(f"GPU share: {m['gpu']/total:.1%}")
print(f"Total cost: ${m['cost']:.2f}")

5. Supply Chain and Six-Year Iteration Strategy

5.1 Key Supply Agreements

SupplierProductRoleStrategy
BroadcomIris designSelf-developedCo-development
TSMCIris manufacturingSelf-developed foundryAdvanced node lock
SamsungMemory chipsGPU/ASIC memoryExternal procurement
SanDiskFlash storageData center storageExternal procurement
Sumitomo ElectricFiber opticsData center interconnectExternal procurement

5.2 Six-Generation Roadmap

MTIA v4 Iris (2026H2, 3nm, 450 TFLOPS) → MTIA v5 (2027H1, 3nm+, 600 TFLOPS) → MTIA v6 (2027H2, 2nm, 800 TFLOPS)

6-year iterations: MTIA = 6 generations vs NVIDIA = 4 generations. 1.5x iteration speed.

6. Industry Impact

  1. Self-developed chips becoming standard: Meta, Google (TPU), Amazon (Trainium), Microsoft (Maia), OpenAI (Jalapeño)
  2. “Complement, not replace” is consensus: No one dares to fully abandon established suppliers
  3. TSMC is the common foundation: All routes lead to TSMC
  4. Iteration speed defines competitiveness: 6-month cycle vs 18-month cycle

7. Conclusion

Meta Iris chip’s September mass production marks a new phase where AI computing infrastructure moves from “single-pole supply” to “multi-polar parallel.” The 7GW to 14GW capacity doubling relies not on Iris replacing NVIDIA, but on parallel construction of “self-developed inference + external training + supporting supply chain.”

Key figures:

  • Mass production: September 2026
  • Verification: 6 weeks (industry standard: 12-18 months)
  • Capacity target: 7GW (2026), 14GW (2027)
  • CapEx: $145 billion (2026)
  • Iteration cadence: New chip every 6 months
  • Supply chain: 5 long-term agreements covering all critical components

Based on Reuters’ July 9 disclosure of Meta’s internal memo, CITIC research reports, and Forrester analyst commentary. Chip specifications are reasonable estimates based on public information.