Back to feed
News Story
NVIDIA Developer Blog
1 sources

ModelExpress: Distributing Model Artifacts at the Speed of Light

ModelExpress is a system designed to efficiently distribute large model artifacts (checkpoints) across clusters, addressing the high cost of moving hundreds of gigabytes or terabytes of data. It optimizes for common operations like cold starts, autoscaling, and rolling updates in AI training and deployment.

SynthePulse Insight · AI deep reading

ModelExpress: Making Model Weight Transfer Catch Up to GPU Compute Speed

Version 1 · 1 source

NVIDIA's ModelExpress aims to solve the bottleneck of weight transfer in large model deployment. By intelligent path selection and GPU direct transfer, it reduces cold start time from 8 minutes to 1 minute 44 seconds.

  • ModelExpress prioritizes transferring weights from already running service replicas via inter-GPU P2P RDMA, avoiding repeated loading from object storage or local disk.
  • When no replica is available, ModelExpress supports streaming loading from object storage (bypassing local disk) or loading directly to GPU via GPUDirect Storage from local storage.
  • For the DeepSeek-V4 Pro model (806 GiB), ModelExpress controls weight and JIT kernel cache transfer time within 10 seconds, reducing total startup time from 8 minutes to 1 minute 44 seconds.
  • ModelExpress uses atomic distributed caching to avoid duplicate downloads within the cluster: when multiple replicas request concurrently, only one replica downloads from external sources, and the rest reuse the cache.
  • ModelExpress has been integrated with inference frameworks such as vLLM, SGLang, Dynamo, and llm-d, and supports receive-driven RL weight update workflows.
Open section navigationCore Idea: First Ask 'Where Are Compatible Replicas?', Then Choose the Fastest Path

Core Idea: First Ask 'Where Are Compatible Replicas?', Then Choose the Fastest Path

ModelExpress's core design philosophy is: before loading a model, first query the cluster for compatible weight replicas. If a serving replica exists, transfer directly via inter-GPU P2P RDMA (using NVIDIA Inference Xfer Library, NIXL), bypassing object storage, local disk, and host memory. If no replica is available, start from the fastest supported path, such as streaming from object storage without landing to disk, or reading directly into GPU via GPUDirect Storage from local storage.

This design transforms each new replica's startup from an independent cold start into a fan-out transfer between GPUs. As more replicas join, the source pool expands, and subsequent replicas load faster.

Cold Start Optimization: Multi-Path Acceleration from Storage to GPU

For the first worker node (no available replica), ModelExpress offers multiple optimized paths from storage. When loading from remote object storage, the Model Streamer uses a multi-threaded tensor reader to concurrently pull safetensors, feeding them directly into GPU via a reusable CPU staging buffer, avoiding data landing to disk. In tensor parallel deployments, participating nodes divide the reading and share results, rather than each node independently downloading the full checkpoint.

When the cluster maintains a shared disk cache layer, ModelExpress's atomic distributed cache ensures only one external download: an atomic claim in the metadata store selects one downloader, while other replicas track progress and reuse the cache. For local storage, if GPUDirect Storage is supported, it reads directly into GPU via NIXL's multi-threaded backend, bypassing host memory; otherwise, it pipelines local reads via ModelStreamer, overlapping disk I/O with GPU placement.

Core Acceleration: Inter-GPU P2P RDMA Transfer

Once a serving replica exists in the cluster, ModelExpress treats it as a live weight source. The control plane discovers compatible replicas, exchanges transfer metadata, and tracks source readiness, but never handles weight bytes. The data plane uses NIXL by default, whose pluggable backend supports InfiniBand, RoCE, and other networks, enabling direct GPU-to-GPU transfer.

Tests show that for the DeepSeek-V4 Pro model (806 GiB), ModelExpress transfers weights and JIT kernel cache from a serving replica to a new replica within 10 seconds, reducing total startup time from 8 minutes to 1 minute 44 seconds. After loading, the new replica joins the source pool, providing more transfer sources for subsequent replicas.

Integration and Extension: Support for RL Weight Updates and Mainstream Inference Frameworks

ModelExpress not only supports cold start and elastic scaling but also applies to reinforcement learning post-training scenarios: in receive-driven RL weight update workflows, updated weights from the trainer can be distributed to rollout workers via inter-GPU transfer.

ModelExpress has been integrated with inference frameworks such as vLLM, SGLang, Dynamo, and llm-d, and includes optimizations like VMM arena registration, significantly reducing startup and registration overhead in production LLM deployments.

Credibility boundary

This article's information comes from NVIDIA's official technical blog, a first-party technical announcement. All performance data (e.g., reduction from 8 minutes to 1 minute 44 seconds, 10-second transfer time) are claims by the NVIDIA team under specific test environments; actual results may vary depending on cluster configuration, network conditions, and other factors.

Insight takeaway

ModelExpress compresses large model weight loading from minutes to seconds through intelligent path selection and GPU direct transfer, providing critical infrastructure for cold start, elastic scaling, and RL training in large-scale LLM deployment.

Primary report

NVIDIA Developer Blog

Primary source