Dynamo Router Starter
OpenAIOfficialCreated by Dan GilDistributed by OpenAI
- Skill
- Tool integration
- Software development
- Apache-2.0
- Medium risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
Dynamo Router Starter provides a standardized procedure for initializing and patching Dynamo router configurations. It supports multiple routing strategies including round-robin, KV-aware, and least-loaded modes. The skill includes instructions for both local Python-based setups and Kubernetes deployments, ensuring that the frontend is correctly configured and that backend workers are properly registered. It also provides a health check script to verify model discovery and basic chat completion functionality, helping users transition from initial bring-up to functional validation.
What it does
- Configures Dynamo frontend router modes via CLI or Kubernetes environment variables.
- Supports various routing strategies like round-robin, KV-aware, and least-loaded.
- Provides a smoke test script to verify model availability and chat completion endpoints.
- Offers guidance on enabling approximate KV mode when worker events are unavailable.
- Facilitates the transition from initial setup to troubleshooting if endpoints fail.
- Standardizes the validation process for Dynamo router deployments.
When to use it
- When setting up a new Dynamo router instance locally or in Kubernetes.
- When switching between different routing modes to optimize traffic distribution.
- When verifying that a deployed Dynamo frontend is correctly communicating with backend workers.
- When performing initial smoke tests before running full-scale performance benchmarks.
Advantages
- Simplifies complex router configuration by providing clear CLI and YAML patterns.
- Ensures consistent validation through automated health check scripts.
- Helps identify common configuration issues like missing worker registrations or KV event mismatches.
- Provides a clear path for troubleshooting when endpoints are unhealthy.
Usage examples
- “Start a local Dynamo frontend in KV-aware mode on port 8000 and verify it.”
- The agent executes the frontend command with the appropriate flags and runs the health check script to confirm the endpoint is operational.
- “How do I configure my Kubernetes Dynamo frontend for KV routing?”
- The agent provides the necessary environment variable patches for the frontend service, including the option to toggle approximate KV mode.
- “Run a smoke test on my Dynamo router at http://127.0.0.1:8000.”
- The agent invokes the health check script against the specified URL to verify model discovery and chat completion success.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/openai/dynamo-router-starter/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip dynamo-router-starter.zip -d .agents/skills
Documentation by Dan Gil
Dynamo Router Starter
<!-- SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. SPDX-License-Identifier: CC-BY-4.0 -->
Purpose
Make Dynamo routing feel easy by getting a baseline router mode running, enabling KV-aware routing when appropriate, and proving the endpoint works. Keep the user focused on exact commands and success signals, not router internals.
Prerequisites
Python 3.10+ with the
dynamopackage importable (python3 -m dynamo.frontend --helpworks).For Kubernetes runs:
kubectlconfigured with access to the target namespace and a deployed Dynamo recipe.Network reachability to the frontend service (port-forward or direct).
A model already loaded into at least one worker (
/v1/modelsreturns at least one entry).
Required Inputs
Collect or infer:
local Python/CLI or Kubernetes recipe path
desired mode:
round-robin,kv,least-loaded,device-aware-weighted,direct, orrandomfrontend port or Kubernetes frontend service
whether workers publish KV events; if not, use approximate KV mode
model name for smoke requests, if
/v1/modelscannot discover it
Instructions
1. Establish A Baseline
For local bring-up with already registered workers:
python3 -m dynamo.frontend --router-mode round-robin --http-port 8000For Kubernetes, inspect the selected recipe deploy.yaml and locate the
frontend service. If the recipe is not already deployed, use
dynamo-recipe-runner first.
2. Enable KV Routing
For local frontend:
python3 -m dynamo.frontend --router-mode kv --http-port 8000For Kubernetes, patch only the frontend service env:
envs:
- name: DYN_ROUTER_MODE
value: kvIf backend workers are not publishing KV cache events, set approximate mode instead of leaving the router waiting for events:
envs:
- name: DYN_ROUTER_USE_KV_EVENTS
value: "false"3. Smoke Test
After port-forwarding the frontend service or starting local frontend, run:
python3 scripts/check_router_health.py \
--base-url http://127.0.0.1:8000This must verify /v1/models and, when a model is discoverable, one
/v1/chat/completions request.
4. Compare Modes Carefully
When comparing round-robin vs KV routing:
use the same model, workers, prompt set, concurrency, and sampling settings
send repeated-prefix prompts if demonstrating KV reuse
label the result as a smoke comparison unless enough benchmark samples were collected
do not claim throughput improvement from a single chat request
If the endpoint is unhealthy or workers are missing, switch to
dynamo-troubleshoot.
Available Scripts
| Script | Purpose | Arguments |
|---|---|---|
scripts/check_router_health.py | Smoke-test /v1/models and one chat completion against a Dynamo frontend | --base-url, --retries, --timeout |
Invoke via the agentskills.io run_script() protocol:
run_script("scripts/check_router_health.py", args=["--base-url", "http://127.0.0.1:8000"])Examples
Local KV-routed frontend on port 8000, then smoke-test it:
python3 -m dynamo.frontend --router-mode kv --http-port 8000 &
python3 scripts/check_router_health.py --base-url http://127.0.0.1:8000Kubernetes-deployed frontend reachable via port-forward:
kubectl port-forward svc/qwen-vllm-disagg-frontend 8000:8000 -n dynamo-demo &
python3 scripts/check_router_health.py --base-url http://127.0.0.1:8000 --retries 3Equivalent through the agent protocol:
run_script("scripts/check_router_health.py", args=["--base-url", "http://127.0.0.1:8000", "--retries", "3"])Output Contract
Return:
mode selected and why
local command or Kubernetes env patch
frontend service or URL
smoke-test result
any limitation, such as approximate KV mode or missing worker KV events
next command to run for a fuller comparison
Limitations
Smoke test is one chat completion; it is not a benchmark. Use
dynamo-benchmarkfor throughput/latency numbers.KV-aware mode without worker KV-event publication degrades to approximate mode; this skill flags but does not fix the underlying worker config.
Mode comparisons require matched workloads; cross-mode latency claims need separate benchmark runs.
Troubleshooting
| Symptom | Likely cause | Next step |
|---|---|---|
/v1/models returns empty list | No worker registered with the frontend | Verify worker pods are Ready; confirm they connect to the same etcd/NATS |
| Smoke chat request times out | Frontend up, workers not serving | Switch to dynamo-troubleshoot; inspect worker logs |
| KV mode hangs | Workers do not publish KV cache events | Set DYN_ROUTER_USE_KV_EVENTS=false (approximate mode) |
| Connection refused on port-forward | Port-forward dropped or wrong service name | Re-run port-forward; verify the frontend service name matches the recipe |
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
Read
references/router-modes.mdfor the compact mode/env map.Use
scripts/check_router_health.pyfor endpoint smoke tests.
Files
- ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
- BENCHMARK.md2.6 KiB
- LICENSEAdded by AutoGineer10.0 KiB
- SKILL.md5.6 KiB
- agents/openai.yaml303 B
- evals/evals.json3.0 KiB
- references/router-modes.md2.1 KiB
- scripts/check_router_health.pyScript4.7 KiB
- skill-card.md2.4 KiB
- skill.oms.sig5.0 KiB
skill-card.md
Description: <br>
Start or patch Dynamo router modes and run router endpoint smoke checks. <br>
This skill is ready for commercial/non-commercial use. <br>
Owner
NVIDIA <br>
License/Terms of Use: <br>
Apache-2.0 <br>
Use Case: <br>
Developers and engineers configuring Dynamo routing modes (round-robin, KV-aware, least-loaded, or device-aware) and verifying endpoint health via smoke tests. <br>
Deployment Geography for Use: <br>
Global <br>
Known Risks and Mitigations: <br>
Risk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. <br> Mitigation: Review and scan skill before deployment. <br>
Reference(s): <br>
Dynamo Releases <br>
Skill Output: <br>
Output Type(s): [Shell commands, Configuration instructions] <br> Output Format: [Markdown with inline bash code blocks] <br> Output Parameters: [1D] <br> Other Properties Related to Output: [None] <br>
Evaluation Metrics Used: <br>
Reported benchmark dimensions: <br>
Security: Checks whether skill-assisted execution avoids unsafe behavior such as secret leakage, destructive commands, or unauthorized access. <br>
Correctness: Checks whether the agent follows the expected workflow and produces the correct final output. <br>
Discoverability: Checks whether the agent loads the skill when relevant and avoids using it when irrelevant. <br>
Effectiveness: Checks whether the agent performs measurably better with the skill than without it. <br>
Efficiency: Checks whether the agent uses fewer tokens and avoids redundant work. <br>
Skill Version(s): <br>
1.2.0 (source: pyproject.toml) <br>
Ethical Considerations: <br>
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this skill meets requirements for the relevant industry and use case and addresses unforeseen product misuse. <br>
(For Release on NVIDIA Platforms Only) <br> Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns here. <br>
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 a command-line tool, Needs Python
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-router-starter · 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-router-starter.zip