Wuxiang Cloud Valley Token Factory: 200 Billion Tokens Per Hour — The Engineering Blueprint of China's First Commercial Token Factory

Wuxiang Cloud Valley Token Factory: 200 Billion Tokens Per Hour — The Engineering Blueprint of China’s First Commercial Token Factory

1. Introduction

In July 2026, a landmark event occurred in China’s AI infrastructure landscape: Runjiang Co.’s Wuxiang Cloud Valley (五象云谷) AI Computing Center announced itself as the nation’s first commercially operational “Token Factory” — producing approximately 200 billion tokens per hour. Customers no longer need to rent racks or manage clusters; they simply connect via API and pay by token, like using electricity from a utility.

The numbers behind this are staggering: China’s daily AI token consumption surged from approximately 100 billion in early 2024 to over 140 trillion by March 2026 — a 1,000-fold increase in just two years. Yet simultaneously, the average rack utilization rate of domestic AI computing centers hovers at only 20-30%, with some enterprise centers below 10%.

“Owning computing power ≠ having productivity” — this alarm is ringing over the entire industry.

┌──────────────────────────────────────────────────────────────────────────┐
│              The Core Paradox of AI Computing: Demand vs Utilization      │
├──────────────────────────────────────────────────────────────────────────┤
│                                                                           │
│  Demand Side:                         Supply Side:                       │
│  ┌──────────────────┐               ┌──────────────────┐                 │
│  │ Daily Token Usage │               │ DC Utilization   │                 │
│  │ 2024: ~100B      │               │ Industry Avg:    │                 │
│  │ 2026: >140T      │   →Imbalance→ │ 20-30%          │                 │
│  │ Growth: 1000x+   │               │ Some: <10%      │                 │
│  └──────────────────┘               │ GPU Idle Severe │                 │
│                                      └──────────────────┘                 │
│                                                                           │
│  Token Factory Solution: Computing Power Like Water & Electricity        │
│  ┌──────────────────────────────────────────────────────────┐             │
│  │ Wuxiang Cloud Valley: 200B tokens/hr | 57% utilization   │             │
│  │ PUE<1.1 | Customers: API → Pay per token → No GPU ops    │             │
│  └──────────────────────────────────────────────────────────┘             │
│                                                                           │
└──────────────────────────────────────────────────────────────────────────┘

2. The “Five-Layer Cake” Architecture of the Token Factory

Jensen Huang’s “AI Five-Layer Cake” framework — from bottom to top: Energy → Chips → Infrastructure → Models → Applications — describes losses at each layer. The core competitiveness of the Wuxiang Cloud Valley Token Factory lies in its ability to optimize across all five layers simultaneously.

2.1 Energy Layer: From 220KV Substation to Microchannel Liquid Cooling

Electricity costs account for 50-60% of total operating expenses in the inference phase. Power-computing synergy is the lifeblood of the Token Factory.

220KV Dedicated Substation + SST800V High-Voltage DC Power Supply: Traditional data centers undergo multiple AC→DC→AC→DC conversions, each losing 5-10% of energy. High-voltage DC simplifies this to AC→DC, reducing transmission losses by 8-12%.

Microchannel Indirect Liquid Cooling: Coupled with AI-driven frequency modulation to dynamically adjust cooling capacity, power is maximally converted into effective computing rather than dissipated as heat. The final PUE is compressed to the 1.1x range (industry average: 1.3-1.5).

"""
Wuxiang Cloud Valley Power-Computing Synergy Simulation
"""

import numpy as np
from dataclasses import dataclass


@dataclass
class PowerChainConfig:
    grid_voltage_kv: float = 220.0
    transformer_efficiency: float = 0.98
    dc_voltage_v: int = 800
    pue_target: float = 1.12
    it_load_mw: float = 50.0


class PowerChainSimulator:
    """Simulate the full energy flow from 220KV grid to GPU computing"""
    
    def __init__(self, config: PowerChainConfig):
        self.config = config
    
    def compare_chains(self):
        """Compare traditional vs HVDC power chains"""
        print("=" * 70)
        print("Wuxiang Cloud Valley - Power Chain Comparison")
        print("=" * 70)
        
        input_power = self.config.it_load_mw / self.config.pue_target
        
        # Traditional chain: 6 stages, multiple AC/DC conversions
        traditional_stages = [
            ("Grid Input", 1.0, input_power),
            ("Main Transformer 220KV→10KV", 0.98, input_power * 0.98),
            ("UPS Rectifier AC→DC", 0.95, input_power * 0.98 * 0.95),
            ("UPS Inverter DC→AC", 0.95, input_power * 0.98 * 0.95 * 0.95),
            ("PDU Distribution", 0.97, input_power * 0.98 * 0.95 * 0.95 * 0.97),
            ("Server PSU AC→DC", 0.94, input_power * 0.98 * 0.95 * 0.95 * 0.97 * 0.94),
            ("GPU Board Power", 0.92, input_power * 0.98 * 0.95 * 0.95 * 0.97 * 0.94 * 0.92),
        ]
        
        # HVDC chain: 5 stages, single AC→DC conversion
        hvdc_stages = [
            ("Grid Input", 1.0, input_power),
            ("220KV Dedicated Substation", 0.99, input_power * 0.99),
            ("SST800V HVDC Rectifier", 0.97, input_power * 0.99 * 0.97),
            ("HVDC Direct to GPU (No Inverter)", 0.99, input_power * 0.99 * 0.97 * 0.99),
            ("GPU Board Power", 0.96, input_power * 0.99 * 0.97 * 0.99 * 0.96),
        ]
        
        traditional_loss = 1 - traditional_stages[-1][2] / traditional_stages[0][2]
        hvdc_loss = 1 - hvdc_stages[-1][2] / hvdc_stages[0][2]
        
        print(f"\nIT Load: {self.config.it_load_mw} MW")
        print(f"Target PUE: {self.config.pue_target}")
        
        print(f"\n[1] Traditional Chain:")
        for name, eff, power in traditional_stages:
            print(f"  {name}: {eff*100:.0f}% → {power:.2f} MW")
        print(f"  Total Loss: {traditional_loss*100:.1f}%")
        print(f"  GPU Effective Power: {traditional_stages[-1][2]:.2f} MW")
        
        print(f"\n[2] Wuxiang Cloud Valley HVDC Chain:")
        for name, eff, power in hvdc_stages:
            print(f"  {name}: {eff*100:.0f}% → {power:.2f} MW")
        print(f"  Total Loss: {hvdc_loss*100:.1f}%")
        print(f"  GPU Effective Power: {hvdc_stages[-1][2]:.2f} MW")
        
        print(f"\n[3] Efficiency Gain:")
        print(f"  Power Utilization: {(1-hvdc_loss)/(1-traditional_loss)*100:.1f}%")
        print(f"  Loss Reduction: {(1-hvdc_loss/traditional_loss)*100:.1f}%")


if __name__ == "__main__":
    sim = PowerChainSimulator(PowerChainConfig(it_load_mw=50.0, pue_target=1.12))
    sim.compare_chains()

2.2 Computing Layer: Rundaostar Scheduling Platform

Wuxiang Cloud Valley deploys both international mainstream and domestic computing chips. By breaking through NVIDIA P2P limitations, using BF3 networking cards, and parallel storage, the Rundaostar (润道星算) scheduling platform pools GPU clusters into a unified elastic resource pool, achieving approximately 57% cluster utilization (industry average: below 30%).

// Rundaostar Platform - GPU Cluster Pooling Scheduler
package main

import (
    "fmt"
    "math"
    "sort"
)

type GPUNode struct {
    ID          string
    Model       string
    MemoryGB    int
    TFLOPS      float64
    IsAvailable bool
    PowerW      int
    Utilization float64
    Queue       []Task
}

type Task struct {
    ID           string
    ModelName    string
    Priority     int
    InputTokens  int
    OutputTokens int
    MaxLatencyMs int
}

type ClusterScheduler struct {
    Nodes       []GPUNode
    TotalTokens int64
}

func (s *ClusterScheduler) AddNode(node GPUNode) {
    s.Nodes = append(s.Nodes, node)
}

func (s *ClusterScheduler) ScheduleTask(task Task) string {
    sort.Slice(s.Nodes, func(i, j int) bool {
        return s.Nodes[i].Utilization < s.Nodes[j].Utilization
    })
    
    for i := range s.Nodes {
        if s.Nodes[i].IsAvailable && s.Nodes[i].MemoryGB >= task.InputTokens/1000000 {
            s.Nodes[i].Queue = append(s.Nodes[i].Queue, task)
            s.Nodes[i].Utilization = math.Min(
                float64(len(s.Nodes[i].Queue)*(task.InputTokens+task.OutputTokens))/
                    float64(s.Nodes[i].MemoryGB*1000000), 1.0)
            s.TotalTokens += int64(task.InputTokens + task.OutputTokens)
            return s.Nodes[i].ID
        }
    }
    return ""
}

func (s *ClusterScheduler) PrintStats() {
    fmt.Println("=" * 70)
    fmt.Println("Rundaostar Platform - GPU Cluster Scheduling")
    fmt.Println("=" * 70)
    
    totalUtil := 0.0
    totalPower := 0
    totalNodes := len(s.Nodes)
    activeNodes := 0
    
    for _, n := range s.Nodes {
        if n.IsAvailable {
            activeNodes++
        }
        totalUtil += n.Utilization
        totalPower += n.PowerW
    }
    
    avgUtil := totalUtil / float64(totalNodes)
    fmt.Printf("\nCluster Overview:\n")
    fmt.Printf("  Total Nodes: %d\n", totalNodes)
    fmt.Printf("  Active Nodes: %d\n", activeNodes)
    fmt.Printf("  Avg Utilization: %.1f%%\n", avgUtil*100)
    fmt.Printf("  Total Power: %.1f MW\n", float64(totalPower)/1e6)
    fmt.Printf("  Total Tokens: %.0f billion\n", float64(s.TotalTokens)/1e9)
    
    fmt.Printf("\nPerformance Comparison:\n")
    fmt.Printf("  Industry Avg Utilization: 20-30%%\n")
    fmt.Printf("  Wuxiang Cloud Valley: 57%%\n")
    fmt.Printf("  Improvement: %.0f%%\n", (0.57/0.25-1)*100)
    fmt.Printf("  First Token Response: +30%% improvement\n")
}

func main() {
    scheduler := &ClusterScheduler{}
    
    // Simulate a 10,000-GPU cluster
    gpuModels := []string{"H100", "H200", "B200", "Ascend 910B"}
    for i := 0; i < 10000; i++ {
        model := gpuModels[i%len(gpuModels)]
        var memGB, powerW int
        var tflops float64
        
        switch model {
        case "H100":
            memGB, powerW, tflops = 80, 700, 1979
        case "H200":
            memGB, powerW, tflops = 141, 700, 1979
        case "B200":
            memGB, powerW, tflops = 192, 1000, 4500
        case "Ascend 910B":
            memGB, powerW, tflops = 96, 400, 512
        }
        
        scheduler.AddNode(GPUNode{
            ID: fmt.Sprintf("GPU-%s-%05d", model, i),
            Model: model, MemoryGB: memGB, TFLOPS: tflops,
            IsAvailable: true, PowerW: powerW,
            Utilization: 0.57,
        })
    }
    
    for i := 0; i < 50000; i++ {
        scheduler.ScheduleTask(Task{
            ID: fmt.Sprintf("TASK-%06d", i),
            InputTokens: 1000 + (i*17)%5000,
            OutputTokens: 500 + (i*31)%2000,
            MaxLatencyMs: 200,
        })
    }
    
    scheduler.PrintStats()
}

2.3 Infrastructure Layer: 2 Microsecond Network Latency

Wuxiang Cloud Valley uses IB/RoCE high-speed networking, reducing network latency to under 2 microseconds. Through computing power pooling, SLB load balancing, EAS auto-scaling, and intelligent routing, resource utilization is optimized to millisecond-level response.

2.4 Model Layer: 16+ Model App Store

The platform integrates over 16 mainstream open-source and closed-source models, creating an “AI Model App Store.” Using P/D separation (Prefill/Decode separation) and KV Cache technology, enterprises can select and call models without building their own model libraries.

2.5 Application Layer: Quchi AI Platform + OPC Factory

The Quchi (曲尺) AI open platform packages underlying computing and model capabilities into directly callable AI agents and industry applications, driving AI adoption across telecom, energy, government, education, agriculture, healthcare, and low-altitude economy sectors.

3. The Token Economy Model

3.1 Business Model Transformation

3.2 Time-Differentiated Pricing

Wuxiang Cloud Valley uses dynamic pricing to shift demand:

• Off-peak (0:00-8:00): 30% discount, powered by low-cost green energy
• Peak (8:00-12:00, 14:00-18:00): 20% premium for real-time inference
• Standard (12:00-14:00, 18:00-24:00): Base price

4. The “Five-in-One” Capability

Wuxiang Cloud Valley’s parent company, Runjiang Co. (润建股份), has 23 years of experience in telecom O&M, spanning telecom networks × energy networks × computing networks. This “Five-in-One” capability forms the Token Factory’s moat:

1. Energy: Located in Guangxi, a green energy province with 175.8 billion kWh clean energy in 2025
2. Computing: RunDo energy hub + Rundaostar platform, achieving 57% cluster utilization
3. Network: Adjacent to Nanning International Telecom Gateway (200m), connecting to ASEAN with ~20ms latency to Singapore
4. Policy: Guangxi FTZ approved for “incoming data processing” pilot, first ASEAN-oriented computing hub
5. Commercialization: First commercially operational Token Factory in China

5. Industry Significance

The 200 billion tokens per hour production capacity validates a key industry trend: when AI capabilities are broken down into standardized, clearly priced token units, the technology leaves the laboratory and becomes true social infrastructure.

Wuxiang Cloud Valley has proven that a complete commercial loop can work — from the 220KV substation to SST800V HVDC, from microchannel liquid cooling to the RunDo energy hub, from the Rundaostar scheduling platform to the Quchi AI open platform, from API-based token billing to time-differentiated pricing. The entire chain is fully connected.

As industry analysts observe: “Whoever can first and stably run the complete chain of converting electricity into computing power, and computing power into tokens, will hold the ticket to the next AI era.”

Based on reports from Securities Times, China Economic News, 36Kr, Science and Technology Daily, and other public sources.

• ←Previous
• Next→