Nvidia DSX MaxLPS 2026: Squeezing Watts Per AI Factory

Nvidia’s DSX MaxLPS reference design landed this week alongside a much quieter but far more revealing move: Nvidia taking an equity stake in Cloverleaf Infrastructure, a power developer that builds gigawatt-scale grid interconnects. Read those two events together and the message is unambiguous — the company that sells GPUs is now investing in electricity, because electricity is what its customers cannot buy. For anyone sizing 2026-2027 racks, the Nvidia DSX MaxLPS spec is not a nice-to-have optimization guide; it determines whether your utility contract is correctly sized or catastrophically wrong. The binding constraint on AI buildouts has shifted from allocation to amperage, and the reference designs have finally caught up.

What’s new in Nvidia DSX MaxLPS

DSX MaxLPS is a reference architecture, not a product SKU. It sits on top of the existing DSX datacenter blueprint family and specifies how to configure a full AI factory hall — power delivery, liquid cooling loops, rack topology, and scheduler policy — for maximum useful work per watt rather than maximum peak FLOPS. The “MaxLPS” name refers to aggressive use of low-power states across the GPU fleet. Instead of treating idle and near-idle accelerators as a rounding error, the design assumes that at gigawatt scale, the delta between an idle GPU at 15 percent of TDP and one properly parked at low single digits is measured in tens of megawatts across a campus.

Three things in the spec are genuinely new relative to previous DSX guidance. First, it treats the power envelope as the fixed input and compute as the derived output: you tell the design how many megawatts you have contracted, and it works backward to rack count, coolant delta-T, and sustained clock targets. Every prior reference design worked the other direction. Second, it formalizes LPS scheduling as a first-class orchestration concern. Workload placement must be power-aware, with drain-and-park behavior for accelerators that fall below a utilization floor, and explicit ramp policies so that a fleet coming out of low-power state does not create a step load the substation cannot absorb. Third, it assumes direct-to-chip liquid cooling as the baseline, not the premium option, and relegates air-cooled configurations to a compatibility appendix.

The Cloverleaf Infrastructure investment is the other half of the story. Cloverleaf specializes in the unglamorous work of securing interconnection queue positions, negotiating with utilities, and structuring behind-the-meter generation for large loads. Nvidia putting capital there tells you what its own demand modeling says: it can fab the silicon, but if operators cannot energize the buildings, the silicon does not ship. Vendor equity in the power supply chain is the clearest possible signal of where the bottleneck now sits in gigawatt AI datacenter power planning.

Why it matters

• Utility contracts are now the long-lead item. GPU lead times have compressed to quarters; interconnect queues in ERCOT, PJM, and much of Northern Virginia run three to seven years. Size your contracted load off peak nameplate TDP times rack count and you will over-procure by 30 to 40 percent and pay demand charges on capacity you never draw — or under-procure and stall a build.
• Performance per watt is becoming the procurement metric. AI factory performance per watt, expressed as tokens or training-samples per megawatt-hour, is replacing raw FLOPS in RFPs. That reframes the comparison between accelerator generations: a chip with higher TDP can still win if its sustained-clock efficiency under liquid cooling is better.
• Liquid cooled GPU rack design stops being optional. At 130-150 kW per rack, air cooling does not close thermally at any reasonable hall density. Facilities designed in 2024 for 40 kW racks need CDU retrofits, floor loading review, and often new water treatment programs before they can host 2026 hardware.
• Step load becomes a grid-relationship problem. A synchronized fleet exiting low-power state is a multi-megawatt step change in seconds. Utilities are beginning to write ramp-rate limits into large-load agreements. If your scheduler cannot stagger wake-up, you negotiate from a weak position.
• Stranded capacity is the dominant financial risk. Datacenter energy efficiency in 2026 is less about PUE and more about utilization of contracted power. A hall drawing 60 percent of its contracted megawatts burns margin every hour regardless of how efficient the cooling plant is.
• Vertical integration is spreading upstream. The Cloverleaf Infrastructure and Nvidia tie-up will not be the last. Expect accelerator vendors, hyperscalers, and independent power producers to keep entangling, which changes who you negotiate with and what leverage you hold.

How to use Nvidia DSX MaxLPS today

You do not need to be building a gigawatt campus to extract value from this. The techniques below apply to a single rack or a single hall, and the numbers you generate are exactly what you should bring to a utility or colo negotiation.

1. Measure your actual power draw distribution, not your nameplate. Sample every GPU at short intervals for at least a full weekly cycle. Nameplate TDP is a terrible planning input; the p50 and p99 of real draw are what matter.

   nvidia-smi --query-gpu=index,name,power.draw,power.limit,utilization.gpu,temperature.gpu,clocks.sm \
     --format=csv,noheader,nounits -l 5 >> power_trace.csv

2. Compute your real headroom ratio. The gap between p99 draw and nameplate is capacity you pay for and never use. Anything above roughly 20 percent is a contract-sizing conversation.

   import pandas as pd
   
   cols = ["idx","name","draw_w","limit_w","util","temp_c","sm_mhz"]
   df = pd.read_csv("power_trace.csv", names=cols)
   
   per_gpu = df.groupby("idx")["draw_w"]
   p50, p99, cap = per_gpu.median().sum(), per_gpu.quantile(0.99).sum(), df.groupby("idx")["limit_w"].max().sum()
   
   print(f"p50 fleet draw : {p50/1000:.1f} kW")
   print(f"p99 fleet draw : {p99/1000:.1f} kW")
   print(f"nameplate cap  : {cap/1000:.1f} kW")
   print(f"headroom vs p99: {100*(1-p99/cap):.1f}%")
   
   idle = df[df.util < 5]
   print(f"idle-state watts burned: {idle.draw_w.sum()/len(df.idx.unique())/720:.0f} W-avg/GPU")

3. Cap power and measure the efficiency curve. Most training and inference workloads lose far less throughput than power when capped. Sweep the cap, record tokens or samples per second, and find the knee.

   # sweep from nameplate down in 50W steps
   for CAP in 700 650 600 550 500 450; do
     sudo nvidia-smi -pl $CAP
     echo "=== cap ${CAP}W ==="
     ./run_benchmark.sh --duration 300 --report throughput
   done
   sudo nvidia-smi -pl 700   # restore

   A typical result: capping at 75 percent of nameplate costs 8-12 percent throughput. That is a 25 percent power reduction for roughly a tenth of the work — a straight win on performance per watt, and it directly shrinks the megawatts you must contract.

4. Enable persistence mode and set an explicit idle policy. Without it, driver reload latency pushes operators toward leaving GPUs hot. With it, parking becomes cheap enough to actually use.

   sudo nvidia-smi -pm 1
   sudo nvidia-smi -lgc 210,1410     # floor/ceiling SM clock, MHz
   sudo nvidia-smi --auto-boost-default=0

5. Make your scheduler power-aware. Consolidate work onto fewer fully loaded nodes and drain the rest rather than spreading thinly across a half-idle fleet. In Kubernetes, that means binpacking plus a taint on parked nodes.

   apiVersion: kubescheduler.config.k8s.io/v1
   kind: KubeSchedulerConfiguration
   profiles:
     - schedulerName: power-aware
       pluginConfig:
         - name: NodeResourcesFit
           args:
             scoringStrategy:
               type: MostAllocated          # binpack, do not spread
               resources:
                 - name: nvidia.com/gpu
                   weight: 10
   ---
   # park a drained node
   # kubectl taint nodes gpu-node-17 power=parked:NoSchedule
   # kubectl label nodes gpu-node-17 power-state=lps

6. Stagger wake-up to respect ramp limits. Bringing 400 nodes out of low-power state simultaneously is a step load. Ramp them in cohorts.

   RAMP_COHORT=25      # nodes per step
   RAMP_INTERVAL=45    # seconds between steps
   
   kubectl get nodes -l power-state=lps -o name | \
     xargs -n "$RAMP_COHORT" sh -c '
       for n in "$@"; do
         kubectl taint "$n" power=parked:NoSchedule- 2>/dev/null
         kubectl label --overwrite "$n" power-state=active
       done
       echo "cohort resumed: $*"
       sleep '"$RAMP_INTERVAL"'
     ' _

7. Instrument coolant delta-T alongside power. In a liquid-cooled hall, return temperature is your real efficiency signal. A narrow delta-T means you are pumping more water than you need and losing free-cooling hours.

   curl -s -u "$BMC_USER:$BMC_PASS" -k \
     https://$CDU_HOST/redfish/v1/Chassis/1/ThermalSubsystem/CoolantConnectors/0 \
     | jq '{supply: .SupplyTemperatureCelsius,
            ret:    .ReturnTemperatureCelsius,
            delta:  (.DeltaTemperatureCelsius),
            flow:   .FlowLitersPerMinute,
            kw:     .HeatRemovedkW}'

8. Bring one number to the utility. Contracted load should be p99 fleet draw under your chosen power cap, plus cooling and facility overhead, plus a defensible growth factor — not nameplate times rack count. Document the LPS and ramp policy; utilities increasingly price flexible load better than firm load.

How it compares

Approach	Cooling baseline	Planning input	Power-state management	Best fit
Nvidia DSX MaxLPS	Direct-to-chip liquid, air as appendix	Contracted megawatts, working backward to rack count	First-class: drain, park, cohort ramp, utilization floors	Gigawatt-class greenfield AI factories
Earlier DSX / MGX blueprints	Mixed air and liquid	Target FLOPS, working forward to power	Advisory, largely left to the operator	Existing halls adding GPU capacity incrementally
AMD Instinct platform guidance	Liquid for top SKUs, air widely supported	Rack thermal budget	Driver-level caps, less orchestration guidance	Operators prioritizing memory capacity per dollar
Hyperscaler in-house designs (TPU, Trainium)	Purpose-built liquid loops	Fleet-wide energy budget	Deeply integrated with proprietary schedulers	Single-tenant operators who control the whole stack
Open Compute Project ORV3 / Mount Diablo	Vendor-neutral liquid-ready racks	Rack power envelope	Out of scope — hardware spec only	Multi-vendor halls wanting interoperable infrastructure

What’s next

Watch the interconnection queues more closely than the product roadmaps. The gating factor on 2027 capacity is how many gigawatts of large-load interconnects actually energize, and that number is set by transformer lead times, transmission upgrades, and regulator patience — none of which respond to demand signals on a semiconductor cadence. Expect more behind-the-meter generation deals, more gas turbines sited next to halls as bridge power, and more scrutiny from public utility commissions about who pays for the grid upgrades. The Cloverleaf Infrastructure investment is Nvidia buying visibility and influence in exactly that process.

On the technical side, the interesting frontier is closing the loop between the scheduler and the meter. Most power-aware scheduling today is open-loop: you set a cap, you binpack, you hope. The next step — and one the MaxLPS framing points directly at — is a control plane that reads real-time facility power and coolant telemetry and modulates clocks and placement to hold a target draw. That makes an AI factory a dispatchable load, which changes its economics entirely: flexible load gets better rates, better queue positions, and in some markets gets paid for curtailment. Operators who can demonstrate controllable ramp behavior will sign materially better contracts than those who cannot.

Expect the efficiency conversation to move up the stack as well. Hardware and cooling improvements are approaching diminishing returns compared to what quantization, speculative decoding, better batching, and smarter routing deliver. The largest wins in AI power constraint management over the next two years will come from serving the same requests with fewer accelerator-seconds, not from shaving another point off PUE. Reference designs like DSX MaxLPS are necessary infrastructure hygiene, but they are the floor, not the ceiling.

Frequently Asked Questions

Is DSX MaxLPS a product I can buy?

No. It is a reference design — a specification and set of recommended practices that OEMs and operators build against. You buy the systems and infrastructure that conform to it. The practical value for most teams is the methodology: size for contracted power, treat low-power states as a scheduling primitive, and assume liquid cooling.

Does power capping meaningfully hurt training performance?

Less than most people assume. Modern accelerators spend significant time waiting on memory and interconnect, so the top slice of the power curve buys very little throughput. Measured across common training and inference workloads, a cap at roughly three-quarters of nameplate typically costs under 12 percent throughput. Sweep it on your own workload before committing — the knee position varies with how memory-bound the job is.

Can I retrofit an air-cooled hall for liquid-cooled GPU rack design?

Sometimes, but treat it as a serious project rather than an upgrade. You need CDU placement and the electrical capacity to run them, floor loading review for the added mass, a water treatment and leak-detection program, and often a rethink of hot-aisle containment that no longer does much. Rear-door heat exchangers are the common intermediate step, taking a hall from roughly 40 kW to 70-80 kW per rack without a full direct-to-chip conversion.

What is the actual risk of not doing this?

Two failure modes, both expensive. Over-contracting means paying demand charges on megawatts you never draw, sometimes for a decade. Under-contracting means finished buildings with racks that cannot energize, waiting in an interconnection queue while the hardware depreciates. Accurate power modeling keeps you off both ends.

Why would a chip company invest in a power developer?

Because unsold capacity is the risk. Nvidia can produce accelerators faster than customers can energize the buildings to house them, so capital deployed into grid interconnection directly protects its own demand. Read it as a demand-modeling disclosure: the company’s own forecast says power, not fab capacity, sets the ceiling on 2027 revenue.

Does any of this apply to a small cluster?

The measurement and capping steps do, immediately, and they pay back fastest at small scale where every kilowatt shows up on a bill you personally see. The interconnect and ramp-policy material is a genuinely gigawatt-scale concern. If you run under a few hundred kilowatts, do steps one through four, skip the utility negotiation, and revisit when you outgrow your building’s service.