
Dynamo Router Starter
OfficialFreeSimplify routing setup and health checks for Dynamo.
Free · Opens the source repo
What Dynamo Router Starter does
The Dynamo Router Starter is designed to streamline the process of setting up and managing routing modes for Dynamo applications. It allows developers to easily start or patch various router modes, such as round-robin and KV-aware routing, while also providing tools for smoke testing the health of router endpoints. This makes it easier to focus on application logic rather than the complexities of router configurations.
To use the Dynamo Router Starter, you need to have Python 3.10 or higher and the dynamo package installed. It also requires access to a deployed Dynamo recipe and network reachability to the frontend service. Once the prerequisites are met, users can establish a baseline router mode, enable KV routing, and perform health checks to ensure that the system is functioning correctly.
This skill is particularly useful for developers and engineers working with Dynamo-based applications who need to quickly set up routing configurations and verify their functionality. By providing clear commands and success signals, the Dynamo Router Starter simplifies the process of managing routing modes, allowing users to concentrate on their core development tasks.
While the skill is effective for initial setup and health checks, it is important to note that it is not a benchmarking tool. Users should utilize additional benchmarking tools for performance metrics, as the smoke tests provided by this skill only cover basic functionality and do not reflect throughput or latency improvements.
When to use it
Use this skill when you need to quickly configure routing modes and perform health checks on Dynamo endpoints.
When not to use it
This skill is not suitable for in-depth performance benchmarking or when detailed analysis of routing performance is required.
What you can build with it
Local Development Setup
Quickly establish a local Dynamo routing setup using the round-robin mode for testing.
Kubernetes Deployment
Patch the frontend service in a Kubernetes environment to enable KV-aware routing for efficient model access.
Health Check Verification
Run smoke tests to verify that your Dynamo router endpoints are functioning correctly after setup.
How to install Dynamo Router Starter
View source1. Install with the skills CLI
npx skills add nvidia/skills/dynamo-router-starter --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by nvidiaDynamo 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, orrandom - frontend 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 8000
For 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 8000
For Kubernetes, patch only the frontend service env:
envs:
- name: DYN_ROUTER_MODE
value: kv
If 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:8000
This 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:8000
Kubernetes-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 3
Equivalent 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.
Frequently asked questions about Dynamo Router Starter
Similar skills
Turborepo
Optimized build system for JavaScript/TypeScript monorepos.
Azure Pipelines Validation
Streamline your Azure DevOps pipeline changes locally.
Azure Developer CLI
Streamline your Azure project workflows with best practices.
Azure Container Registry CLI
Manage Azure Container Registry resources with ease.
Aspire
Build and orchestrate polyglot distributed applications seamlessly.
Vercel CLI
Manage and deploy Vercel projects from the command line.
