Dynamo Interconnect Check
OpenAIOfficialCreated by Dan GilDistributed by OpenAI
- Skill
- Review and audit
- Cloud and DevOps
- Apache-2.0
- Medium risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
Dynamo Interconnect Check is a read-only diagnostic tool designed to verify that the transport layer for disaggregated serving is correctly configured. It ensures that NIXL, UCX, and NCCL are properly utilizing RDMA and NVLink for KV cache and tensor exchanges. By inspecting environment variables, node capabilities, and NIXL reachability, it helps operators confirm that their multi-node or disaggregated deployments are performing optimally and not silently falling back to slower, non-optimized transport paths.
What it does
- Inspects recipe configuration for critical NIXL, UCX, and NCCL environment variables.
- Probes worker pods for InfiniBand, GPUDirect RDMA, GDRCopy, and NVLink capabilities.
- Validates NIXL reachability and surfaces instructions for pairwise transfer testing.
- Provides a clear verdict on whether the disaggregated transport is ready for production use.
- Identifies missing tools or misconfigured fabric settings that could degrade performance.
When to use it
- Immediately after deploying a disaggregated or multi-node recipe via recipe-runner.
- Before benchmarking disaggregated throughput or latency to ensure valid results.
- When a deployment is functional but exhibits slow performance or unexpected behavior.
- To verify transport configuration consistency across different worker nodes.
Advantages
- Prevents reliance on deployments that are silently using sub-optimal transport paths.
- Provides actionable feedback on missing environment variables or fabric issues.
- Non-intrusive, read-only diagnostic approach that does not mutate cluster state.
- Helps distinguish between model-level issues and underlying fabric misconfigurations.
Usage examples
- “Check the transport environment variables for my qwen3-coder-480b disagg recipe.”
- The agent runs the env check script against the specified recipe path to report on critical NIXL/UCX/NCCL variables.
- “Validate the fabric capabilities for worker pod qwen-worker-0 in the dynamo-demo namespace.”
- The agent probes the pod for RDMA, GPUDirect, and NVLink status, returning a readiness verdict.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/openai/dynamo-interconnect-check/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip dynamo-interconnect-check.zip -d .agents/skills
Documentation by Dan Gil
Dynamo Interconnect Check
<!-- SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. SPDX-License-Identifier: CC-BY-4.0 -->
Purpose
Confirm that the transport disaggregated serving depends on actually works. A deployment can pass an endpoint smoke test while disagg is silently wrong: if NIXL/UCX cannot reach the peer worker over RDMA or NVLink, KV transfer falls back to a slow or broken path. Catch that with read-only checks before trusting a disagg deployment or its benchmark numbers.
This skill is read-only. It never mutates the cluster and never prints secrets.
Prerequisites
Python 3.10+ on the operator machine.
kubectl execaccess to a worker pod in the target Dynamo deployment.Read access to the recipe directory (
recipes/<model>/<framework>/<mode>).For node-capability checks: tools like
ibstat,nvidia-smi,lsmodavailable in the worker pod image (missing tools are reported asskipped, not failures).
When To Use
After
dynamo-recipe-runnerdeploys a disagg or multi-node recipe.Before reporting disagg throughput/latency, so numbers reflect the real transport.
When agg works but disagg is slow, hangs, or returns wrong output and you suspect the fabric rather than the model.
For diagnosing pods that are already crashing or unschedulable, use
dynamo-troubleshoot first.
Instructions
1. Check Transport Env Vars On The Recipe
python3 scripts/check_interconnect.py env recipes/<model>/<framework>/<mode>Reports which NIXL/UCX/NCCL transport variables are set and flags
disagg-critical ones (e.g. UCX_TLS, UCX_NET_DEVICES, NCCL_IB_HCA) that are
absent. Missing here is only a warning — they may be baked into the image — so
confirm with the node and NIXL checks. See
references/interconnect-env-vars.md for what each variable does.
2. Check Node Capabilities
Locally on a GPU node, or inside a running worker pod:
python3 scripts/check_interconnect.py node \
--namespace "${NAMESPACE}" --pod <worker-pod>Probes (read-only) for: InfiniBand devices and Active links, GPUDirect RDMA
(nvidia_peermem), GDRCopy, and NVLink in the GPU topology. Missing tools are
reported as skipped, not failures.
3. Validate NIXL Reachability
python3 scripts/check_interconnect.py nixl \
--namespace "${NAMESPACE}" --pod <worker-pod>Looks for NIXL test tooling in the pod and surfaces the exact next step to run a pairwise prefill↔decode transfer test. A full cross-pod transfer test requires two scheduled GPU pods on the fabric.
Available Scripts
| Script | Purpose | Arguments |
|---|---|---|
scripts/check_interconnect.py env | Inspect NIXL/UCX/NCCL env vars on a recipe | positional recipe path |
scripts/check_interconnect.py node | Probe InfiniBand, GPUDirect RDMA, GDRCopy, NVLink on a node or pod | --namespace, --pod |
scripts/check_interconnect.py nixl | Surface NIXL transfer-test readiness for a pod | --namespace, --pod |
Invoke via the agentskills.io run_script() protocol:
run_script("scripts/check_interconnect.py", args=["env", "recipes/qwen3-coder-480b/sglang/disagg"])
run_script("scripts/check_interconnect.py", args=["node", "--namespace", "dynamo-demo", "--pod", "qwen-worker-0"])Examples
Verify a disagg recipe's transport env shape before deploy:
python3 scripts/check_interconnect.py env recipes/qwen3-coder-480b/sglang/disaggAfter deploy, validate a worker pod's fabric:
python3 scripts/check_interconnect.py node \
--namespace dynamo-demo --pod qwen-worker-0
python3 scripts/check_interconnect.py nixl \
--namespace dynamo-demo --pod qwen-worker-0Equivalent through the agent protocol:
run_script("scripts/check_interconnect.py", args=["nixl", "--namespace", "dynamo-demo", "--pod", "qwen-worker-0"])Output Contract
Each check returns ok / warn / fail / skipped with a one-line detail,
plus a rolled-up verdict on disagg transport readiness. Report:
transport env vars present vs. disagg-critical ones missing
RDMA / GPUDirect / NVLink capability status
whether NIXL reachability was validated, and the next command if not
a clear statement of whether disagg can be trusted, or what to fix first
Limitations
Read-only fabric probe; does not run a full pairwise NIXL transfer (requires two scheduled GPU pods and the in-pod NIXL test tools).
skippedresults for missing tools (ibstat,nvidia-smi,lsmod) are inconclusive, not a pass.Env-var check inspects the recipe text; values injected at runtime via initContainers or operator-applied envs are not detected.
Single-node agg deployments do not exercise the transport — this skill is for disagg / multi-node validation.
Troubleshooting
| Symptom | Likely cause | Next step |
|---|---|---|
env reports all critical vars missing | Vars baked into image or injected by operator | Run the node check inside the worker pod to verify actual env |
node reports no Active IB link | Fabric down or HCA not provisioned to the node | Contact cluster admin; verify kubectl describe node shows nvidia.com/gpu and IB labels |
nvidia_peermem missing | GPUDirect RDMA module not loaded | Ask cluster admin to load nvidia-peermem; without it, NIXL falls back to staged copies |
nixl finds no test tools | Worker image lacks NIXL test harness | Use a NIXL-enabled image or run the standalone transfer test from a debug pod |
Benchmark
See BENCHMARK.md for the NVCARPS-EVAL performance report (auto-generated by the NVSkills CI pipeline). To refresh, re-run /nvskills-ci on an upstream PR touching this skill.
References
references/interconnect-env-vars.md— NIXL/UCX/NCCL env var catalog and IB capability checklist.Use
scripts/check_interconnect.pyfor all read-only checks.
Files
- ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
- BENCHMARK.md2.9 KiB
- LICENSEAdded by AutoGineer10.0 KiB
- SKILL.md6.3 KiB
- agents/openai.yaml365 B
- evals/evals.json3.1 KiB
- references/interconnect-env-vars.md3.5 KiB
- scripts/check_interconnect.pyScript12.8 KiB
- skill-card.md2.5 KiB
- skill.oms.sig5.0 KiB
references/interconnect-env-vars.md
Dynamo Interconnect Env Vars & IB Capability Checklist
<!-- SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. SPDX-License-Identifier: CC-BY-4.0 -->
Disaggregated serving moves KV cache between prefill and decode workers over
NIXL (which uses UCX underneath), and tensor/expert-parallel workers exchange
data over NCCL. Both ride the same fabric — InfiniBand/RoCE RDMA across nodes
and NVLink within a node. If that fabric is misconfigured, a deployment still
serves /v1/models but disagg is slow or wrong. The variables below decide
which transport gets used.
NIXL / UCX (KV cache transport)
| Variable | Disagg-critical | Purpose |
|---|---|---|
UCX_TLS | yes | Allowed transports. Include rc/IB and cuda_ipc/cuda_copy for RDMA + NVLink. If it resolves to tcp only, KV transfer crawls. |
UCX_NET_DEVICES | yes | Pins UCX to a specific HCA/port (e.g. mlx5_0:1). Unset or wrong device falls back to the management NIC. |
UCX_IB_GPU_DIRECT_RDMA | yes | Enables GPUDirect RDMA so the NIC DMAs straight to/from GPU memory. |
UCX_RNDV_SCHEME | no | Rendezvous scheme for large messages (put_zcopy / get_zcopy / auto). |
NIXL_PLUGIN_DIR | no | Backend plugin search path; only for non-default install layouts. |
NCCL (collective transport)
| Variable | Disagg-critical | Purpose |
|---|---|---|
NCCL_IB_HCA | yes | IB HCAs NCCL may use (e.g. mlx5_0,mlx5_1). |
NCCL_SOCKET_IFNAME | yes | NIC for NCCL bootstrap/rendezvous (e.g. eth0, ib0). A wrong guess hangs init. |
NCCL_IB_DISABLE | yes | Must be 0/unset to use InfiniBand; 1 forces sockets. |
NCCL_NET_GDR_LEVEL | no | GPUDirect RDMA aggressiveness (SYS/PHB/PIX). |
NCCL_P2P_LEVEL | no | NVLink/PCIe peer-to-peer level for intra-node collectives. |
NCCL_IB_GID_INDEX | no | GID index for RoCE/EFA fabrics; not needed on classic IB. |
NCCL_DEBUG | no | Set to INFO to print the transport NCCL actually selected. |
IB / GPUDirect / NVLink capability checklist
The node check probes these read-only; here is what each tells you:
/dev/infiniband+ibv_devinfo -l— RDMA devices are exposed to the pod. Empty means no RDMA (often a missing device plugin orhostNetwork/ resource request).ibstat→State: Active/LinkUp— the IB/RoCE port is actually up.Down/Pollingmeans cabling, subnet manager, or fabric issues.nvidia_peermem(or legacynv_peer_mem) loaded — GPUDirect RDMA kernel support; without it RDMA stages through host memory./dev/gdrdrv— GDRCopy present, used for low-latency small transfers.nvidia-smi topo -mshowingNV#— NVLink links between GPUs for intra-node KV/collective traffic;PIX/PXBrows show GPU↔NIC affinity, which should line up withUCX_NET_DEVICES/NCCL_IB_HCA.
Validating NIXL reachability
Capabilities being present does not prove two workers can talk. To actually exercise the path, run a pairwise transfer between a prefill pod and a decode pod (different nodes for the RDMA path, same node for NVLink) using the NIXL test/bench tooling shipped in the worker image, e.g.:
# in the worker image; exact binary/flags depend on the NIXL build
kubectl exec -n "${NAMESPACE}" <prefill-pod> -- nixlbench --helpIf the transfer fails or silently uses TCP, fix the env vars and capabilities
above before trusting any disagg result. Set NCCL_DEBUG=INFO and inspect UCX
logs to confirm the selected transport.
Requirements and compatibility
Written for: OpenAI Codex
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs Python, Needs Node.js
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Dan Gil
- Publisher
- OpenAI (Official)
- Distributed by
- OpenAI
- Source
- openai/plugins · plugins/nvidia/skills/dynamo-interconnect-check · commit d420d13
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (written by AutoGineer)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
- Also distributed in
- NVIDIA/skills
AutoGineer is not affiliated with or endorsed by Dan Gil or OpenAI.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download dynamo-interconnect-check.zip