Generated banner for Dynamo Interconnect Check
Generated logo for Dynamo Interconnect Check

Dynamo Interconnect Check

OpenAIOfficialCreated by Dan GilDistributed by OpenAI

  • Skill
  • Review and audit
  • Cloud and DevOps
  • Apache-2.0
  • Medium risk
  • Has scripts

From the author

Validate that a Dynamo deployment's NIXL/UCX/NCCL interconnect is ready for disaggregated serving over RDMA/NVLink. Use after recipe-runner brings a deployment up (especially disagg/multi-node) to confirm the KV transport is correct; use troubleshoot for diagnosing already-failed pods.
— the description by Dan Gil

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/openai/dynamo-interconnect-check/download
  2. Unzip 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 exec access 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, lsmod available in the worker pod image (missing tools are reported as skipped, not failures).

When To Use

  • After dynamo-recipe-runner deploys 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

ScriptPurposeArguments
scripts/check_interconnect.py envInspect NIXL/UCX/NCCL env vars on a recipepositional recipe path
scripts/check_interconnect.py nodeProbe InfiniBand, GPUDirect RDMA, GDRCopy, NVLink on a node or pod--namespace, --pod
scripts/check_interconnect.py nixlSurface 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/disagg

After 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-0

Equivalent 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).

  • skipped results 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

SymptomLikely causeNext step
env reports all critical vars missingVars baked into image or injected by operatorRun the node check inside the worker pod to verify actual env
node reports no Active IB linkFabric down or HCA not provisioned to the nodeContact cluster admin; verify kubectl describe node shows nvidia.com/gpu and IB labels
nvidia_peermem missingGPUDirect RDMA module not loadedAsk cluster admin to load nvidia-peermem; without it, NIXL falls back to staged copies
nixl finds no test toolsWorker image lacks NIXL test harnessUse 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.py for all read-only checks.

Files

BENCHMARK.md

Evaluation Report

Evaluation of the dynamo-interconnect-check skill before publication through NVSkills-Eval.

This benchmark summarizes 3-Tier Evaluation from NVSkills-Eval results for the skill. The goal is to document whether the skill is safe, discoverable, effective, and useful for agents before it is published for broader workflow use.

Evaluation Summary

  • Skill: dynamo-interconnect-check

  • Evaluation date: 2026-05-28

  • NVSkills-Eval profile: external

  • Overall verdict: PASS

  • Tier 3 live agent evaluation: not available in this report

Agents Used

  • Tier 3 agent details were not available in this report.

Metrics Used

Reported benchmark dimensions:

  • Security: checks whether skill-assisted execution avoids unsafe behavior such as secret leakage, destructive commands, or unauthorized access.

  • Correctness: checks whether the agent follows the expected workflow and produces the correct final output.

  • Discoverability: checks whether the agent loads the skill when relevant and avoids using it when irrelevant.

  • Effectiveness: checks whether the agent performs measurably better with the skill than without it.

  • Efficiency: checks whether the agent uses fewer tokens and avoids redundant work.

Underlying evaluation signals used in this run:

  • No Tier 3 evaluation signal details were available in this report.

Test Tasks

Tier 3 evaluation task details were not available in this report.

Results

Tier 3 dimension rollup was not available in this report.

Tier 1: Static Validation Summary

Tier 1 validation passed with observations. NVSkills-Eval ran 9 checks and found 5 total findings.

Top findings:

  • MEDIUM SECURITY/Unknown (LP3): MCP Least Privilege: The skill invokes shell commands via kubectl exec and reads files from the filesystem (recipe directories), but does n (SKILL.md:1)

  • LOW QUALITY/quality_discoverability: Description very long (286 chars, recommend 50-150) (skills/dynamo-interconnect-check/SKILL.md)

  • LOW SCHEMA/unexpected_file: Unexpected 'skill-card.md' in skill root (skills/dynamo-interconnect-check/skill-card.md)

  • LOW SCHEMA/unexpected_file: Unexpected 'skill.oms.sig' in skill root (skills/dynamo-interconnect-check/skill.oms.sig)

  • LOW SCRIPT_LINT/magic_numbers: check_interconnect.py contains magic numbers (skills/dynamo-interconnect-check/scripts/check_interconnect.py)

Tier 2: Deduplication Summary

Tier 2 validation passed. NVSkills-Eval ran 2 checks and found 0 total findings.

Notable observations:

  • Context Deduplication: Collected 3 file(s)

  • Inter-Skill Deduplication: Parsed skill 'dynamo-interconnect-check': 286 char description

Publication Recommendation

The skill is suitable to proceed toward NVSkills-Eval publication based on this benchmark. Skill owners should keep this file with the skill and refresh it when the evaluation dataset, skill behavior, or target agents materially change.

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