TensorRT Multi-GPU in Dynamo-Triton 26.07: Config and Benchmark Interpretation

This is a config-and-benchmark-interpretation guide for NVIDIA’s September 21, 2026 Dynamo-Triton example. To serve a TensorRT network across several GPUs through one model endpoint, the model must already be compiled as a distributed TensorRT plan. NVIDIA’s example uses a single KIND_MODEL instance, enable_multi_device set to true, and the participating GPU IDs in multi_device_gpus. That config activates a compatible plan; it does not turn an ordinary single-GPU engine into a multi-GPU one.

For the published example, pin the NVIDIA Cosmos 3 Nano walkthrough to Dynamo-Triton/Triton 26.07 and TensorRT 11.1 as packaged in that release. The 26.07 release notes list Triton 2.71.0, TensorRT 11.1.0.106, CUDA 13.3.4.1 and NCCL 2.30.7. TensorRT multi-device inference became fully supported in TensorRT 11.0; TensorRT 10.16 treated it as a preview. The version distinction matters if you are comparing older examples or build images.

Check the version and GPU path first

NVIDIA says the Dynamo-Triton TensorRT backend added multi-device inference in release 26.07. The official release notes identify the server image contents and say the 26.07 container supports compute capability 7.5 or later. For the distributed-collective path in the Cosmos Ulysses example, the current TensorRT multi-device guide specifies Ampere-class GPUs (SM 80) or later. It lists a separate requirement for multi-device attention—Blackwell (SM 100) or later—but NVIDIA says its Cosmos example wraps standard attention with distributed collective layers and does not use that separate attention operator.

Use the GPU, CUDA and driver combination supported by the exact container and plan you deploy. The blog says its benchmark ran on a healthy eight-GPU NVIDIA system but does not name the GPU SKU, so it is not evidence that a particular H100, B200 or other machine reproduced the numbers. Confirm the release’s support matrix and the TensorRT plan’s build/runtime compatibility before allocating the model.

A Dynamo-Triton model config for a distributed plan

This is NVIDIA’s CP8 config.pbtxt excerpt, with the eight GPU ordinals shown in the article. It is the model-serving configuration, not a TensorRT engine-building command:

name: "cosmos3_cp8"
backend: "tensorrt"
max_batch_size: 0

instance_group [
  { kind: KIND_MODEL count: 1 }
]
parameters [
  { key: "enable_multi_device" value: { string_value: "true" } },
  { key: "multi_device_gpus" value: { string_value: "0,1,2,3,4,5,6,7" } }
]

• KIND_MODEL with count: 1 defines one TensorRT model instance that owns the selected devices. It is different from creating eight independent GPU instances.
• enable_multi_device opts that TensorRT model into the backend’s multi-device path.
• multi_device_gpus lists the participating GPU IDs. NVIDIA’s CP8 example lists IDs 0 through 7; use IDs visible to your serving process and keep the list length aligned with the distributed plan.
• max_batch_size: 0 is part of this example’s config. Do not copy it or the model name blindly if your model’s I/O and batch semantics differ.

Triton stores each model’s config beside a numeric version directory. For the example, the repository shape is:

model_repository/
  cosmos3_cp8/
    config.pbtxt
    1/
      model.plan

The default TensorRT plan filename is model.plan. The file in version 1 must be the matching distributed plan, not a regular single-device engine. NVIDIA’s blog does not give a universal export/build command or a complete model I/O config for arbitrary models; match input/output names, shapes and types to your engine and the exact TensorRT backend.

At request time, the application sends one inference request for the named model over the gRPC serving interface. Dynamo-Triton and the TensorRT backend manage the participating ranks and their execution contexts. The client does not issue a separate request to every GPU rank. See NVIDIA’s Triton model-repository layout for the version-folder convention; the multi-device fields remain the NVIDIA blog excerpt above.

What NVIDIA measured—and what it did not

NVIDIA compared single-device (SD) serving with two-, four- and eight-GPU context-parallel runs for Cosmos 3 Nano. Every run generated 189 frames at 1280 × 720 and 24 frames per second, using 35 denoising steps. NVIDIA reports one warm-up followed by five measured complete generations on the same eight-GPU system. Timing includes prompt work, 70 transformer RPCs, classifier-free guidance and scheduler updates, VAE decode and frame postprocessing; model loading and MP4 encoding were excluded.

These are NVIDIA-reported latency results for one video-generation configuration, not an independent DMT benchmark. The eight-GPU run reduced the mean time for one complete generation from 156.595 to 34.183 seconds (4.58× speedup). The measured transformer RPC component fell from 146.192 to 23.993 seconds (6.09×). The RPC share of end-to-end time also fell from 93.4% to 70.2%, leaving prompt work, scheduling, decoding and postprocessing more visible in the total.

NVIDIA explicitly did not measure concurrent request throughput, cost per video or total cost of ownership. More GPUs per request can shorten latency in this workload, but these measurements do not show how many videos the system serves per second or what each video costs. For a deployment decision, benchmark your own model, resolution, sequence length, concurrency, queueing and service-level target, and measure hardware utilization and cost separately.

The post also reports output validation across the same-seed SD, CP2, CP4 and CP8 runs. It sampled frames 0, 47, 94, 141 and 188 and checked temporal variation and image error; CP8 measured MAE 16.316 and PSNR 19.400 dB against the single-device result. NVIDIA does not claim pixel-identical outputs. Treat this as a model-specific validation example, not a universal quality guarantee for other graphs or models.

A short pre-deployment checklist

1. Pin the Dynamo-Triton release and its bundled TensorRT/CUDA/NCCL versions; verify driver and GPU compatibility for the exact container.
2. Build or obtain a distributed TensorRT plan for the intended rank count. Confirm the graph contains the required collective operations; do not assume the serving config performs graph partitioning.
3. Match multi_device_gpus to the process-visible IDs and the rank count expected by the plan.
4. Start with the single-device and multi-device plan on the same inputs. Validate correctness and output quality before comparing timing.
5. Report the number of warm-ups and measured requests, input profile, timing boundaries, concurrency, and GPU count. Keep request latency, throughput and cost as separate metrics.

For a separate example of how to read NVIDIA performance claims without broadening a result beyond its tested workload, see DMT’s Vera Rubin MLPerf analysis. That article covers a different benchmark and is not a Dynamo-Triton setup guide.

Sources and scope

• NVIDIA: Simplifying Model Serving Across Multiple GPUs with TensorRT Multi-Device Integration in Dynamo-Triton (Sep 21, 2026)
• NVIDIA Triton Inference Server 26.07 release notes
• NVIDIA TensorRT 11.0 release notes
• NVIDIA TensorRT Multi-Device Inference documentation (current page checked Sep 23, 2026)

All benchmark numbers and implementation details above are attributed to NVIDIA’s published example. DMT did not build an engine, deploy the service or run the benchmark. The model config excerpt is source-derived and intended to show the multi-device fields; it is not a complete model repository. NVIDIA’s Sep 21 post links to a backend guide under an archived 27.10 documentation path, which is later than this article’s Sep 23 review date, so that page was not used to establish 26.07 behavior.