Beyond the Hype: Deconstructing Zhou Hongyi’s '10 Billion Agents' Prophecy for 2026

At the Chongli Forum this week, amidst the snow-covered slopes where he admits he’s still trying to master the art of skiing, Zhou Hongyi—the combative and often controversial founder of 360 Group—dropped a prediction that makes today’s AI hype look like a warm-up act.

“By 2026, there will be at least 10 billion intelligent agents worldwide.”

To put that in perspective: that’s more agents than humans. Zhou argues that in this new era, a company with a valuation in the mere billions will be considered “small” in the AI sector.

But strip away the headline-grabbing numbers, and you find a significant shift in technical philosophy. Zhou is effectively declaring the end of the “Model Training Era” and the beginning of the “Inference & Agent Era.”

As tech editors who have seen waves of hype come and go, we need to ask: Is this just more noise, or is it a roadmap? Let’s deconstruct Zhou’s 20 predictions, analyze the technical pivot from training to inference, and look at what this actually means for developers and enterprises.

---

1. The Great Pivot: From “Chatbots” to “Colleagues”

If 2024 was the year of the LLM (Large Language Model), Zhou posits that 2025 is the transition year, and 2026 is the year of the Agent.

The “Chatbot” Dead End

Zhou’s critique of the current state of AI is sharp: “Previously, large models were basically in a state of chatbots. They couldn’t do actual work.”

He’s right. A chatbot is passive. You prompt it; it replies. It has no agency, no memory of your previous projects (unless context window allows), and crucially, it cannot go out and do things in other software environments.

The Definition of an Agent

An Agent, in the 2026 vision, is an LLM wrapped in a runtime environment that gives it:

1. Tools: Access to APIs, browsers, and internal databases.
2. Memory: Long-term storage (Vector DBs) to remember user preferences and history.
3. Planning: The ability to break a complex goal (“Plan a marketing campaign”) into steps.

Zhou envisions a “Silicon-based workforce” where digital employees are integrated into the HR system. This isn’t just a metaphor. It implies a fundamental change in software architecture.

💡 The “Second Brain” Concept

Zhou predicts AI will evolve into a “Second Brain”—a digital twin that records, understands, and recalls personal data. This moves beyond RAG (Retrieval-Augmented Generation) into Personalized Knowledge Graphs.

---

2. The Infrastructure Shift: Training is Vanity, Inference is Sanity

One of the most critical technical insights from Zhou’s speech is the decoupling of Training Compute and Inference Compute.

“I think everyone made a mistake in 2024 and 2025 by confusing training power with inference power. Training power is the exclusive domain of a few giant companies. For the vast majority… what is needed is inference power.” — Zhou Hongyi

The Economics of Inference

Currently, the market is obsessed with buying H100 clusters to train models. But once the models are trained, the real cost—and the real energy consumption—comes from running them (inference).

If 10 billion agents are active, they aren’t just chatting. They are performing “Slow Thinking” (System 2 thinking)—reasoning, planning, and self-correcting. This requires significantly more compute per request than a simple ChatGPT query.

The Hardware Implication: Zhou predicts the Nvidia monopoly will crack. While Nvidia dominates training, the inference market is open for ASICs (Application-Specific Integrated Circuits) and specialized chips that are cheaper and more energy-efficient than general-purpose GPUs.

Feature	Training Era (2023-2025)	Inference Era (2026+)
Primary Goal	Create a smarter model	Solve a specific business problem
Compute Profile	Massive parallel throughput	Low latency, high availability
Hardware King	Nvidia (General GPU)	Diverse (Nvidia + ASICs + LPUs)
Cost Driver	CAPEX (Buying chips)	OPEX (Electricity & Token costs)
Bottleneck	Chip supply	Energy supply

The Energy War

Zhou explicitly mentions that the bottleneck will shift from chips to Energy. The “Energy War” is coming. Agents running 24/7 require a stable, massive power supply. This aligns with recent moves by hyperscalers (Microsoft, Amazon) investing in nuclear power.

---

3. The “Builder” Revolution: Why Domain Experts Win

Here is the most empowering part of Zhou’s thesis for non-coders: The protagonists of AI implementation are not AI scientists, but vertical industry experts.

Zhou shared his own experience trying to build a “Short Drama Agent.” He realized that even the best engineers couldn’t code the “sense of camera movement,” “emotional expression,” or “character design.” That knowledge lived in the heads of directors and cameramen.

The “Implicit Knowledge” Problem

Every company has “Dark Data” or “Implicit Knowledge”—unwritten rules, leadership preferences, and specific workflows.

• Explicit Knowledge: Manuals, docs (Easy for AI to learn).
• Implicit Knowledge: “How we actually do things here” (Hard for AI).

The Opportunity: The winners in 2026 will be those who can extract this implicit knowledge and encode it into System Prompts and Knowledge Bases.

🛠️ Technical Implementation: Encoding Domain Expertise

How do you translate “Director’s Intuition” into code? You don’t train a model from scratch; you build a Stateful Agent.

Here is a simplified Python example using a LangChain-style structure to show how domain expertise is injected into an agent:

from typing import List, Dict
from pydantic import BaseModel, Field

# 1. Define the Domain Expertise (The "Director's Rulebook")
# This is where the non-technical expert contributes.
DIRECTOR_GUIDELINES = """
- Emotional scenes must use close-up shots.
- Action sequences require high frame rates and dynamic angles.
- If a character is lying, focus on micro-expressions or hand movements.
"""

class Scene(BaseModel):
    description: str = Field(..., description="The narrative content of the scene")
    camera_angle: str = Field(..., description="Technical camera instruction")
    lighting: str = Field(..., description="Lighting setup based on mood")

# 2. The "Builder" creates the Agent Logic
class DirectorAgent:
    def __init__(self, llm_model):
        self.llm = llm_model
        self.system_prompt = f"""
        You are an award-winning film director. 
        Your job is to convert a script into technical shooting instructions.
        
        CRITICAL RULES (Implicit Knowledge):
        {DIRECTOR_GUIDELINES}
        """

    def analyze_script(self, script_segment: str) -> Scene:
        # The "Inference" step where the model applies the expert rules
        response = self.llm.generate(
            system=self.system_prompt,
            user=f"Analyze this script segment: {script_segment}"
        )
        return response

# 3. Usage
# The engineer builds the pipe, but the quality depends on DIRECTOR_GUIDELINES
# agent = DirectorAgent(gpt_4o)
# scene_plan = agent.analyze_script("John realizes he has been betrayed.")
# print(scene_plan.camera_angle) 
# Output might be: "Extreme Close-up on eyes, shallow depth of field"

Key Takeaway: The code is simple. The value is in the DIRECTOR_GUIDELINES string. That is the intellectual property of the future.

---

4. The Geopolitics of AI: Open Source & Sovereign Models

Zhou highlights the rise of China’s open-source ecosystem (mentioning DeepSeek and Qwen). He notes a “Siphon Effect” where global intelligence flows into these open models.

The “Sovereign Model”

He predicts that nations outside the US/China duopoly will fear becoming “food on the table.” This will drive a demand for Sovereign AI—national infrastructure where countries run open-source models (like DeepSeek-V3 or Llama 3) on their own hardware to preserve data sovereignty.

This creates a massive B2G (Business to Government) market for deploying and securing these models.

---

5. The Critical View: Security as the “Red Line”

Zhou is, at his core, a security guy. 360 Group made its name on antivirus software. Naturally, his prediction includes a heavy emphasis on AI Security.

He warns of the “Black Box” problem. If 10 billion agents are negotiating contracts and moving money automatically, how do we trust them?

The “Constitution” Model

Zhou proposes a “Model Controlling Model” approach. You don’t just trust the worker agent; you deploy a “Gendarmerie Model” (Military Police) whose only job is to audit the worker agent.

Security Architecture for 2026:

1. Worker Agent: Executes tasks (High creativity, high risk).
2. Guardian Agent: Audits outputs against a strict policy (Low creativity, high strictness).
3. Human-in-the-loop: Required for high-stakes decisions.

⚠️ Code Example: Implementing a Guardian Rail

In a production environment, you never let an agent output directly to a user or execute code without a check.

def safety_guardrail(agent_output: str, policy_rules: str) -> bool:
    """
    A separate, smaller, faster model checks the output.
    This is the 'Gendarmerie Model'.
    """
    check_prompt = f"""
    Review the following agent output against these safety rules:
    RULES: {policy_rules}
    
    OUTPUT: {agent_output}
    
    Return 'SAFE' if compliant, 'UNSAFE' if violation found.
    """
    
    # Use a deterministic, lower-temperature model for checking
    verdict = fast_llm.predict(check_prompt)
    
    if "UNSAFE" in verdict:
        log_security_event(agent_output)
        return False
    return True

# Real-world flow
# 1. Agent generates email to client
draft_email = sales_agent.generate_email()

# 2. Guardian checks for promised discounts (Business Logic Safety)
policy = "Do not promise discounts over 20% without manager approval."
if safety_guardrail(draft_email, policy):
    send_email(draft_email)
else:
    flag_for_human_review(draft_email)

---

6. Conclusion: Is the “10 Billion” Figure Real?

Is Zhou Hongyi exaggerating? Probably. 10 billion agents implies more than one agent for every human on earth.

However, if we redefine “Agent” to include every micro-service that uses an LLM to make a decision—from your smart toaster optimizing energy usage to your calendar negotiating meeting times—the number becomes plausible.

The Verdict for 2026:

• Hype: The idea that AGI (Artificial General Intelligence) will magically solve everything. Zhou rightly points out that relying solely on model scaling is unrealistic.
• Reality: The friction of integration. The challenge isn’t building the agent; it’s getting the agent to talk to legacy ERP systems, navigate messy corporate data, and adhere to compliance laws.

Actionable Advice for Today:

1. Stop obsessing over training. Unless you are OpenAI or Google, you don’t need to train a base model. Focus on Inference Engineering.
2. Capture Implicit Knowledge. Start documenting how your experts make decisions. This data is the fuel for your future agents.
3. Prepare for the Energy/Cost crunch. Optimize your prompts and workflows now. In 2026, efficiency will be the primary competitive advantage.

Zhou Hongyi might be at a ski resort trying to separate his upper body from his lower body movements, but his advice on separating Training from Inference is a maneuver every tech leader needs to learn immediately.

---

References:

• Zhou Hongyi at 2026 Chongli Forum (Sina Finance)
• Zhou Hongyi’s “20 Predictions for 2026” (China Daily)