SenseTime TPW Agent: From PUE to Tokens Per Watt — The AIDC System-Level Efficiency Revolution

1. Introduction: A Metrology Revolution for AI Infrastructure

On July 17, 2026, at WAIC 2026’s “Computing-Power and Green Energy Synergy” symposium, SenseTime’s Large Model Infrastructure division unveiled a product that could redefine the industry’s metrics — the Computing-Power-and-Electricity Synergy Agent. But the truly revolutionary aspect isn’t the Agent itself; it’s the new evaluation metric it champions: TPW (Tokens Per Watt).

This metric strikes at the heart of the AI infrastructure paradox: when the four global cloud giants are projected to spend a combined $725 billion in 2026 CapEx (up 77% YoY), when a single 10,000-GPU cluster’s annual electricity bill exceeds ¥1 billion, and when power costs represent over 60% of AIDC TCO — “How many tokens does each kilowatt-hour of my electricity actually produce?” becomes a far more essential question than “What’s my GPU utilization?”

PUE (Power Usage Effectiveness) has dominated data center energy efficiency evaluation for over 20 years. Its fundamental flaw: it only measures “how much electricity reaches the IT equipment,” not “how much value that electricity creates.” In the Token Economy era, an AIDC’s competitiveness isn’t determined by its PUE, but by how many effective tokens each watt of power can sustainably produce.

2. From PUE to TPW: The Inevitable Metric Revolution

2.1 PUE’s Historical Contributions and Current Limitations

PUE = Total Data Center Energy / IT Equipment Energy, with an ideal value of 1.0. Over the past two decades, global top-tier data centers have improved PUE from 2.0+ to around 1.1, with Google and Meta achieving 1.08-1.10.

However, the marginal cost of each 0.01 improvement below 1.1 grows exponentially. Moreover, an AIDC with PUE 1.1 might produce 1000 tokens per kWh while another produces only 300 — because chip utilization, model efficiency, and scheduling strategies differ dramatically.

2.2 TPW: The Core Metric for the Token Economy

TPW = Effective Token Output / Total Electricity Cost (considering both volume and real-time price)

This formula simultaneously addresses three dimensions:

• Compute efficiency: Higher chip utilization and model efficiency yield more tokens per kWh
• Energy cost: Peak-to-valley price differentials can reach 3-5x; intelligent scheduling produces more tokens during low-price periods
• Business alignment: Not all tokens have equal value — high-priority inference tokens are far more valuable than batch processing tokens

SenseTime Lingang AIDC measured results: After deploying the Computing-Power-and-Electricity Synergy Agent, per-unit-cost token output increased by 80%, average electricity price was 10% lower than regional peers, compute load prediction accuracy reached 96%, and annual carbon reduction is estimated at 24,000 tons per 10,000 PFlops.

3. System Architecture of the Computing-Power-and-Electricity Synergy Agent

3.1 The “Compute × Power × Agent” Trinity Architecture

The architecture can be understood as a three-layer model:

┌─────────────────────────────────────────────────────────────┐
│                    Agent Decision Layer                       │
│   ┌──────────┐  ┌──────────┐  ┌──────────┐                 │
│   │Load Pred │  │Price Pred│  │Battery   │                 │
│   └─────┬────┘  └─────┬────┘  └─────┬────┘                 │
│   ┌─────┴────┐  ┌─────┴────┐  ┌─────┴────┐                 │
│   │Capacity  │  │HVAC Coop │  │Compute   │                 │
│   │Control   │  │          │  │Scheduling│                 │
│   └──────────┘  └──────────┘  └──────────┘                 │
├─────────────────────────────────────────────────────────────┤
│                Eight-Level Data Penetration System            │
│  Campus → Cluster → Room → Cabinet → Server → Node → Pod→Job│
├─────────────────────────────────────────────────────────────┤
│           Physical Layer: Compute + Power + Storage           │
│   ┌──────────┐  ┌──────────┐  ┌──────────┐                 │
│   │ GPU Clust│  │Power Dist│  │Battery   │                 │
│   │Domestic  │  │Solar/Grid│  │CATL      │                 │
│   └──────────┘  └──────────┘  └──────────┘                 │
└─────────────────────────────────────────────────────────────┘

3.2 The Eight-Level Data Penetration System

This serves as the “nervous system” of the entire platform. From campus-level to individual job-level, the eight-level penetration ensures every granularity of operational status is perceivable, analyzable, and actionable.

from dataclasses import dataclass, field
from typing import List
from datetime import datetime
from enum import Enum

class MetricType(Enum):
    POWER = "power"
    TEMPERATURE = "temp"
    UTILIZATION = "util"
    THROUGHPUT = "throughput"

@dataclass
class JobMetrics:
    job_id: str
    model_name: str
    gpu_count: int
    power_consumption: float
    token_throughput: float
    gpu_util: float
    
    def tpw_instant(self) -> float:
        return self.token_throughput / max(self.power_consumption, 1)

@dataclass
class CampusMetrics:
    campus_id: str
    total_incoming_power: float
    solar_generation: float
    battery_soc: float

3.3 The Five Algorithmic Decision Chains

The core intelligence of the Agent comes from five interconnected decision chains forming a complete sense-predict-decide-execute-measure loop:

1. Load → Price: Electricity price prediction based on historical load patterns
2. Price → Battery: Charge/discharge optimization using dynamic programming
3. Battery → Demand: Peak shaving for demand charge reduction
4. Compute → PUE: HVAC and cooling system optimization
5. Price → Token: TPW-directed compute scheduling

class TPWAwareScheduler:
    """
    TPW-aware scheduling engine - core decision component
    """
    def __init__(self, gpu_power_watt: float = 700):
        self.gpu_power = gpu_power_watt
    
    def calculate_tpw(self, estimated_tokens: int, 
                      gpu_count: int, duration_h: float,
                      electricity_price: float) -> float:
        power_kw = gpu_count * self.gpu_power / 1000.0
        energy_cost = power_kw * duration_h * electricity_price
        if energy_cost <= 0:
            return float('inf')
        return estimated_tokens / energy_cost
    
    def schedule_tasks(self, tasks, price_forecast, 
                       available_gpus, time_slot_min=30):
        """Schedule tasks to optimal time slots based on TPW"""
        n_slots = len(price_forecast)
        slot_gpu_usage = [0] * n_slots
        schedule = []
        
        sorted_tasks = sorted(tasks, key=lambda t: (
            t['priority'], 
            -self.calculate_tpw(t['tokens'], t['gpus'], 
                               t['duration']/60, min(price_forecast))
        ))
        
        for task in sorted_tasks:
            slots_needed = max(1, task['duration'] // time_slot_min)
            best_tpw = -1
            best_start = -1
            
            for start in range(n_slots - slots_needed + 1):
                if max(slot_gpu_usage[start:start+slots_needed]) + task['gpus'] > available_gpus:
                    continue
                avg_price = sum(price_forecast[start:start+slots_needed]) / slots_needed
                tpw = self.calculate_tpw(task['tokens'], task['gpus'],
                                        task['duration']/60, avg_price)
                if tpw > best_tpw:
                    best_tpw = tpw
                    best_start = start
            
            if best_start >= 0:
                for s in range(best_start, best_start + slots_needed):
                    slot_gpu_usage[s] += task['gpus']
                schedule.append((task['id'], best_start, best_start + slots_needed))
        
        return schedule

4. Six Core Capabilities

The Agent delivers six integrated operational capabilities:

1. IT Load & Power Prediction: 24-72 hour forecasting using triple exponential smoothing and LSTM
2. Electricity Price & Consumption Analysis: Real-time market data integration with multi-dimensional pricing signals
3. Battery Storage Management: Dynamic programming optimization for charge/discharge schedules
4. Capacity Control & Optimization: Dynamic GPU online count adjustment
5. HVAC Collaborative Optimization: Load-cooling-price three-way linkage
6. Compute Scheduling Decisions: TPW-driven real-time task placement

5. Industry Impact: The System Efficiency Era

5.1 From “Scale” to “Efficiency” Paradigm Shift

The Agent’s launch marks a fundamental shift in AI infrastructure competition — from “how many GPUs do you have” to “how many tokens can each watt of your power produce.” TPW unifies electricity price, battery storage, load, and model efficiency into a single optimization target.

5.2 Domestic Chip TPW Advantage

SenseTime’s heterogeneous hybrid inference technology demonstrates that domestic chips can achieve 1.25x the token output of NVIDIA H-series at equivalent cost — not because individual chip performance is higher, but because:

• Lower procurement costs yield more compute per CapEx dollar
• Full-stack adaptation reduces model migration costs to near zero
• The TPW Agent enables finer-grained power management on domestic platforms

5.3 The Computing-Power-Electricity Synergy Ecosystem

SenseTime, together with China Three Gorges Corporation, China Energy Research Society, and other partners, launched the “Computing-Power-Electricity Synergy Ecosystem Consortium,” building a “Source-Grid-Load-Storage-Compute” integrated ecosystem. The underlying logic: when AI compute becomes infrastructure as fundamental as electricity, its pricing and scheduling must be as refined as the power grid’s.

6. Conclusion

The TPW metric marks AI infrastructure’s transition from “extensive expansion” to “precision operations.” The 80% token output improvement is just the beginning. As the computing-power synergy ecosystem expands and AI scheduling algorithms continue to evolve, future AIDCs could see 2-3x further TPW improvements.

From an industry perspective, TPW standardization will profoundly impact:

• AIDC site selection: Regions with lower electricity prices gain significant competitive advantages
• Chip design: Energy efficiency (TOPS/W) will replace absolute compute as the core metric
• Model optimization: Smaller, more efficient inference architectures gain market share
• Electricity markets: AI loads become major market participants, driving more refined pricing mechanisms

When every kilowatt-hour is meticulously optimized, AI can truly become universal infrastructure.

References: Xinhua News, QbitAI, Shangguan News, 36Kr — WAIC 2026 SenseTime coverage

• ←Previous
• Next→