Inside Yang Zhilin's 39-Minute Speech: What Moonshot AI's Founder Revealed About Kimi's Next Chapter

39 Minutes That Redefined Moonshot's Roadmap

Most conference keynotes are exercises in marketing. Product announcements dressed up as insight, demo reels padded with superlatives, and the inevitable "we're just getting started" finale. I've sat through hundreds of them. Very few change how I think about an industry.

Yang Zhilin's 39-minute speech at WAIC 2026 was one of the exceptions.

On the morning of July 18, the Moonshot AI founder took the main stage not to sell a product but to lay out a technical and philosophical roadmap for the next era of artificial intelligence. No flashy video intros, no celebrity appearances, no "one more thing" theatrics. Just a 32-year-old researcher with a slide deck and a remarkably specific vision of where AI is headed.

I watched the full speech twice — once live, once from the recording — and took detailed notes throughout. What follows is my analysis of the five core claims Yang made, what they mean technically, and how they fit into the broader trajectory of AI development. For the full WAIC 2026 coverage, this speech was the intellectual centerpiece of the conference.

The five pillars of Yang's vision:

1. Trillion-parameter training stability — How to train massive models without collapse
2. Long context at dramatically lower cost — Making 1M+ token windows practical for everyone
3. Multimodal joint learning — Text, images, and video learning from the same training pass
4. Master-sub agent architecture — One primary agent coordinating specialized sub-agents
5. From chatting to task completion — The fundamental paradigm shift in how AI creates value

Each of these deserves detailed examination, because together they paint a picture of AI's future that is both more ambitious and more practical than the vague "AGI is coming" narratives we're used to hearing from industry leaders.

Trillion-Parameter Training Stability: The Engineering Breakthrough

Yang opened with what might be the most technically significant claim in the entire speech: that Moonshot AI has solved the training instability problem that has plagued trillion-parameter MoE models for years.

To understand why this matters, you need to appreciate the problem. When you train a Mixture-of-Experts model with hundreds or thousands of experts, you encounter a phenomenon called expert collapse. During training, the routing mechanism that decides which experts handle which tokens starts favoring a small subset of experts. The unfavored experts receive fewer gradients, their parameters stagnate, and eventually they become dead weight — parameters that exist in memory but contribute nothing to the model's output.

This is why most MoE models historically have used far fewer experts than you might expect. GPT-4 was rumored to use 16 experts. Mixtral used 8. Even DeepSeek V2, which pushed the boundary, used "only" 160 experts. K3 uses 896 — more than five times the previous state of the art.

Yang described three engineering innovations that made this possible:

Innovation 1: Stable LatentMoE with Expert Warmup Scheduling. During the early phases of training, K3 uses a modified routing strategy that forces more uniform expert utilization. Instead of letting the router freely choose experts based on token-level scoring, the system applies a "warmup mask" that gradually relaxes over the first 20% of training steps. This ensures all 896 experts receive meaningful gradient updates from the beginning, preventing early collapse.

Innovation 2: Per-Head Muon Optimizer. Standard optimizers (Adam, AdamW) apply gradient updates uniformly across model parameters. Yang's team discovered that in large MoE models, different attention heads learn at dramatically different rates, and a single learning rate schedule causes instability. The Per-Head Muon optimizer tracks gradient statistics independently for each attention head and adjusts learning rates dynamically. Yang showed training loss curves comparing standard AdamW vs. Per-Head Muon — the difference was striking: AdamW showed oscillating loss in the later stages of training (a classic sign of instability), while Muon maintained smooth, monotonic loss decrease throughout.

Innovation 3: Gradient Clipping with Expert-Level Awareness. Traditional gradient clipping applies a global threshold to prevent gradient explosions. In large MoE models, this is too blunt — it clips the gradients of well-behaved experts alongside the ones actually causing instability. K3's approach applies gradient clipping per-expert, monitoring each expert's gradient magnitude independently and intervening only when specific experts show signs of divergence.

The result, according to Yang: K3 achieved 94.2% expert utilization at the end of training, meaning 844 of 896 experts were actively contributing to model outputs. For comparison, he cited (without naming the model) a "major industry MoE model" that achieved only 67% expert utilization — effectively wasting a third of its parameters. The architecture deep dive provides additional technical details on these innovations.

Why should you care? Because training stability at 2.8T parameters directly determines what the model can learn. More active experts means more capacity for specialized knowledge. Higher utilization means less wasted compute. And reproducible stability means other labs can build on this approach — which is exactly what the open-source release on July 27 will enable.

Long Context at Lower Cost: The Commercial Lever

The second pillar of Yang's speech was arguably the most commercially significant: a dramatic reduction in the cost of processing long contexts.

K3 currently supports a 1-million-token context window — already the largest production context window among frontier models. But Yang revealed that the next version will push this further, targeting 4 million tokens at a fraction of the current inference cost.

The key innovation: KDA (Kimi Dynamic Attention) with a novel cost-scaling mechanism. Standard transformer attention has O(n^2) complexity — doubling the context length quadruples the compute cost. KDA achieves something closer to O(n log n) through a combination of:

• Dynamic sparse attention: The model identifies which token pairs require full attention and which can be approximated, applying full attention only where it matters most
• Hierarchical context compression: Older portions of the context are progressively compressed into denser representations while retaining the most relevant information
• AttnRes (Attention Residual): A mechanism that preserves critical long-range dependencies even as context is compressed

Yang presented a cost comparison that made the audience audibly react:

If these numbers hold in production — and Yang demonstrated live inference at 2M tokens during the speech — the commercial implications are enormous.

Consider a law firm that needs to analyze a 500-page contract (roughly 400K tokens). With standard transformer attention, each analysis query costs $0.30 in compute. With KDA, it costs $0.045. For a firm that runs 1,000 such queries per month, that's the difference between $300/month and $45/month in AI inference costs — a reduction that changes the ROI calculation for AI-assisted legal work entirely.

Or consider a software team that feeds their entire codebase (say, 800K tokens) into a model for architecture review. At standard pricing, each review session costs nearly a dollar. With KDA, it costs eight cents. Suddenly, continuous codebase-aware AI assistance becomes economically viable for every development team, not just well-funded ones.

Yang didn't explicitly say this, but the implication was clear: the goal is to make long context so cheap that developers stop thinking about context length as a constraint. When processing 4 million tokens costs less than 40 cents, you don't optimize prompts to save tokens — you just give the model everything and let it figure out what's relevant. The Excel data analysis test demonstrated exactly this kind of unconstrained long-context usage in practice.

Text, Images, and Video Learning Together

The third pillar was the most visually impressive: Yang showed K3's upcoming multimodal capabilities, where text, images, and video are processed and generated within a single, unified model architecture.

Current multimodal models are typically cobbled together from separate components: a vision encoder (like CLIP or SigLIP) that converts images into token-like representations, a language model that processes those representations alongside text, and sometimes a separate image generation module (like a diffusion model) bolted on for output. It works, but it's architecturally inelegant — like translating between three languages at every step instead of thinking in all three simultaneously.

Yang described a fundamentally different approach: unified tokenization across modalities. In this architecture, text tokens, image patches, and video frame sequences are all converted into a shared representation space from the earliest layers of the model. The model doesn't "translate" between modalities — it processes them as different flavors of the same underlying signal.

The demonstration was compelling. Yang showed K3 (presumably a pre-release version) performing the following tasks:

• Visual code review: Given a screenshot of a buggy web application alongside the source code, K3 identified the visual rendering issue (a misaligned CSS grid) and pointed to the exact line of code causing it. No separate vision model was involved — the model processed the image and code in a single forward pass.
• Video understanding: Given a 2-minute product demonstration video, K3 generated a detailed technical specification document that captured UI flows, interaction patterns, and feature descriptions. The model processed all video frames (approximately 3,600 at 30fps) within its context window.
• Image-guided code generation: Given a hand-drawn wireframe sketch on a napkin (photographed with a phone), K3 generated a complete React implementation that matched the sketch's layout, including correct component hierarchy, responsive breakpoints, and styling that interpreted the sketch's intent rather than literally reproducing its rough lines.

What made this different from existing multimodal demos was the seamlessness. There was no visible "hand-off" between a vision model and a language model. The model appeared to genuinely think across modalities, referencing visual details in its code generation and citing specific video timestamps in its documentation.

Yang stated that these capabilities will ship in K3.5, estimated for Q4 2026. If the quality matches the demo, this represents a significant leap over current multimodal offerings. The comprehensive K3 review covers the current model's capabilities, which set the baseline for what K3.5 will build upon.

Master Agent and Sub-Agents: The Parallel Execution Vision

This was the most forward-looking section of the speech, and the one that generated the most discussion in the post-speech Q&A. Yang outlined Moonshot's architecture for autonomous multi-agent systems — a framework where a primary "master agent" decomposes complex tasks and dispatches specialized "sub-agents" to execute them in parallel.

The architecture, as Yang described it, works like this:

Step 1: Task Reception. The master agent receives a complex, high-level task from the user. Example: "Refactor this 50,000-line React codebase to use server-side rendering, add comprehensive tests, update the documentation, and deploy to production."

Step 2: Task Decomposition. The master agent analyzes the task and breaks it into independent sub-tasks, identifying dependencies and parallelism opportunities. For the refactoring example, it might decompose into: (a) analyze current architecture, (b) plan SSR migration, (c) implement SSR changes, (d) write unit tests, (e) write integration tests, (f) update API documentation, (g) update user documentation, (h) create deployment configuration.

Step 3: Sub-Agent Dispatch. Specialized sub-agents are instantiated for each sub-task. Each sub-agent has access to relevant context (the codebase, documentation, test results) and operates independently. Multiple sub-agents can run in parallel — for example, the test-writing agents can work simultaneously on different test suites.

Step 4: Result Aggregation. The master agent collects outputs from all sub-agents, resolves conflicts (e.g., if two sub-agents modified the same file), performs integration checks, and assembles the final deliverable.

Step 5: Validation and Iteration. The master agent runs validation (tests, type checks, build verification) and iterates on any failures, potentially dispatching new sub-agents to fix specific issues.

Yang demonstrated a simplified version of this architecture in action. The master agent was given a task: "Build a REST API for a task management application with user authentication, CRUD operations, real-time notifications, and automated testing." The master agent decomposed this into 12 sub-tasks, dispatched them to 6 sub-agents working in parallel, and produced a complete, tested application in under 8 minutes. The total wall-clock time was 8 minutes; the cumulative compute time across all sub-agents was 34 minutes. That 4.25x parallelism factor is the key economic advantage of the architecture.

The implications for software development are profound. Current AI coding assistants operate sequentially — one prompt, one response, one step at a time. The master-sub agent architecture enables a fundamentally different workflow: describe the end state, and the AI system autonomously executes the entire project plan, handling coordination, conflict resolution, and quality assurance internally.

Yang acknowledged that this architecture is still in early development. The demo used carefully curated tasks, and the system struggles with tasks that have ambiguous requirements or require creative judgment calls. But the trajectory is clear: Moonshot is investing heavily in multi-agent systems as the next major capability frontier. The $5 coding test showed what sequential K3 can do; multi-agent K3 will be a qualitatively different tool.

From Chatting to Getting Things Done: The Paradigm Shift

The most philosophically interesting section of Yang's speech came near the end, when he stepped back from technical details to articulate a broader thesis about where AI is headed.

"The AI competition of the past two years has been about who can chat better," Yang said. "Who gives more natural-sounding responses. Who writes better poetry. Who can explain quantum physics more simply. This is important work, but it's not the endgame."

He paused for effect, then delivered the line that I think will be quoted most frequently from this speech:

"The AI competition of the next five years will be about who can get things done. Not who talks better, but who finishes the task. Not who gives better advice, but who executes better plans."

This is not a new idea — the "agents are the future" narrative has been circulating in AI research circles for years. But Yang's articulation was notable for its specificity and its commercial clarity.

He framed the shift as a progression through three phases:

Phase 1: Information Retrieval (2022-2024). AI as a search engine that answers questions. Value proposition: "Ask me anything." Revenue model: advertising and subscriptions. Think: early ChatGPT.

Phase 2: Content Generation (2024-2026). AI as a creative tool that produces artifacts. Value proposition: "Tell me what to make." Revenue model: per-token API fees and tool subscriptions. Think: current GPT-4, Fable 5, K3.

Phase 3: Task Completion (2026-2028+). AI as an autonomous executor that delivers outcomes. Value proposition: "Tell me what you need done." Revenue model: per-task fees and outcome-based pricing. Think: the multi-agent architecture Yang described.

The economic implications of this progression are enormous. In Phase 1, AI companies compete on knowledge breadth — and the revenue ceiling is the search engine market ($200B+). In Phase 2, they compete on generation quality — and the revenue ceiling is the creative tools market ($50B+). In Phase 3, they compete on execution reliability — and the revenue ceiling is the global services market ($trillions).

Yang's argument is that Phase 3 represents an order-of-magnitude larger opportunity, and that the technical foundations he described (stable training, cheap long context, multimodal understanding, multi-agent coordination) are the prerequisites for entering that phase. Moonshot's entire roadmap is oriented toward Phase 3.

I found this framing compelling because it reframes the entire AI investment narrative. If Yang is right, the companies currently valued on their Phase 2 capabilities (code generation, content creation) are being evaluated on the wrong metrics. The real question is: which companies have the technical architecture to transition to Phase 3? And based on this speech, Moonshot AI has a more detailed plan for that transition than most of their competitors. The K3 launch strategy shows how deliberately Moonshot has been building toward this moment.

What This Means for Developers

Enough theory and strategy. What does Yang's vision mean for the developers who actually use Kimi and K3 today? Let me translate the roadmap into practical implications.

Short-term (next 3 months): The K3 you have today already benefits from the training stability and long-context innovations Yang described. The 1M token context window, the 1679 Code Arena Elo, the MoE architecture — these are all products of the technical foundations Yang outlined. For developers currently evaluating K3, the current model is a genuine reflection of Moonshot's capabilities. The benchmark showdown provides the detailed performance comparison you need for evaluation.

Medium-term (3-6 months): K3.5 will bring multimodal capabilities that change the developer workflow. Imagine pointing your phone at a whiteboard sketch and getting a working prototype. Imagine feeding a screen recording of a bug and getting the fix. The unified multimodal architecture Yang described will make these workflows possible — and at the inference cost reductions he projected, they'll be affordable.

Long-term (6-18 months): The master-sub agent architecture will fundamentally change how developers interact with AI coding tools. Instead of writing individual prompts for individual code changes, you'll describe project-level objectives and let the AI system execute them autonomously. This doesn't eliminate the need for developers — it elevates developers from "code writers" to "system architects" who define objectives, validate outputs, and make judgment calls that AI cannot.

Here's my honest assessment of Yang's 39-minute speech: it was the most technically substantive and strategically clear presentation I've heard from any AI company leader this year. It wasn't perfect — the multimodal demos were clearly curated, the multi-agent architecture is still early, and the cost reduction claims need independent verification. But as a roadmap for where AI is headed, it was more specific, more credible, and more actionable than anything from OpenAI, Google, or Anthropic in recent memory.

Yang Zhilin is asking us to imagine an AI that doesn't just talk — an AI that works. An AI that takes your objectives, plans the execution, coordinates the effort, and delivers the result. That vision is not science fiction. Based on the technical foundations Yang demonstrated, it's engineering in progress. And if Moonshot AI executes on even half of what Yang described, the AI industry of 2028 will look fundamentally different from the AI industry of 2026. The global rankings analysis shows that K3 has already established Moonshot as a credible frontier player — Yang's speech showed that they intend to stay there.