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://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
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