# Does Switchyard Support Distributed Training? A Deep Dive into the NVIDIA-NeMo Routing Engine

> Discover if Switchyard supports distributed training. Learn how this NVIDIA-NeMo routing engine focuses solely on LLM inference, not training or data parallelism.

- Repository: [NVIDIA-NeMo/Switchyard](https://github.com/NVIDIA-NeMo/Switchyard)
- Tags: deep-dive
- Published: 2026-09-11

---

**No, Switchyard does not support distributed training; it is designed exclusively as an LLM inference routing and decision engine without any model training, gradient synchronization, or data parallelism capabilities.**

Switchyard is an open-source Rust-based project maintained by NVIDIA-NeMo that functions solely as a routing layer for large language model (LLM) inference. Unlike training frameworks such as PyTorch Distributed or NVIDIA NeMo’s training utilities, Switchyard focuses entirely on selecting optimal models for incoming requests and translating between different API formats during inference time.

## Understanding Switchyard's Core Architecture

The Switchyard codebase is organized around **inference-time decision making** rather than model training. At its heart lies the `libsy` crate located in [`crates/libsy/src/lib.rs`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/crates/libsy/src/lib.rs), which implements the core routing algorithms.

According to the source code, the primary abstraction is the `Algorithm` trait with its `run_stream` method, which processes requests through a series of discrete steps:

```rust
// Conceptual flow based on crates/libsy/src/lib.rs
async fn run_stream(&self, request: Request) -> StepStream {
    // Yields Step::CallModel or Step::Done
}

```

The routing logic centers on two primary step types: **`Step::CallModel`**, which triggers an external LLM call, and **`Step::Done`**, which signals completion of the routing decision. These types appear in [`crates/libsy/src/lib.rs`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/crates/libsy/src/lib.rs) and confirm that Switchyard operates strictly as a proxy layer between clients and existing model endpoints.

## Why Switchyard Cannot Perform Distributed Training

A thorough analysis of the repository reveals zero implementation of training-specific infrastructure. The codebase lacks:

- **Gradient synchronization** mechanisms required for distributed data parallelism
- **Data loaders** or dataset sharding utilities
- **Model weight update** logic or optimizer states
- **Multi-node communication** backends like NCCL or MPI integrations

The top-level [`README.md`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/README.md) explicitly describes Switchyard’s purpose as routing "each LLM call to the cheapest model that can still do the job." This focus on cost-efficient inference routing precludes any training functionality. When you need **Switchyard distributed training** capabilities, you must look elsewhere—the tool simply does not implement the backward passes, parameter servers, or distributed samplers necessary for training workloads.

## Inference-Time Routing: Switchyard's Actual Function

Instead of training, Switchyard specializes in **stage-based routing algorithms** that dynamically select between models of varying capability and cost. The library provides pre-built algorithms like `stage_router`, which operates on confidence thresholds to decide whether to use an efficient model or fall back to a more capable one.

The Python integration demonstrates this inference-only workflow:

```python
from switchyard.libsy import LlmResponse, Step
from switchyard.libsy.algorithms import stage_router

# Build a stage-router algorithm for intelligent model selection

algorithm = stage_router(
    "capable",
    "efficient", 
    picker="efficient_first",
    confidence_threshold=0.5,
)

async def route(request: dict, clients: dict):
    """Drive the routing algorithm - inference only, no training."""
    async for step in algorithm.run_stream(request):
        match step:
            case Step.CallModel(call):
                # Execute external inference call

                response = await clients[call.models[0]].call(call.request)
                call.respond(LlmResponse.Agg(response))
            case Step.Done(outcome):
                return outcome.response

```

This architecture makes Switchyard a **post-training deployment tool**—it assumes models are already trained and hosted elsewhere (via OpenRouter, NeMo Relay, or custom endpoints), then optimizes which model handles each request.

## Deploying Switchyard for Production Inference

You can run Switchyard as a standalone proxy server or embed it directly into Python applications. The server configuration uses TOML files to define routes between different LLM providers, with no training configuration options available.

To install and run the inference proxy:

```bash

# Install the server from crates/switchyard-server

cargo install --locked switchyard-server

# Configure routes for inference only

cat > routes.toml <<'TOML'
schema_version = 1

[llm_clients.openrouter]
format = "openai_chat"
base_url = "https://openrouter.ai/api/v1"
api_key_env = "OPENROUTER_API_KEY"

[targets.capable]
id = "anthropic/claude-opus-4.8"
llm_client = "openrouter"

[targets.efficient]
id = "z-ai/glm-5.2"
llm_client = "openrouter"

[routes.switchyard]
id = "switchyard"
type = "stage_router"
capable_target = "capable"
efficient_target = "efficient"
picker = "efficient_first"
confidence_threshold = 0.5
TOML

# Start the inference proxy

switchyard-server --config routes.toml --host 127.0.0.1 --port 4000

```

As shown in [`crates/switchyard-server/README.md`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/crates/switchyard-server/README.md), these configurations only handle request forwarding and response aggregation during inference time.

## Summary

- Switchyard is an **inference-only routing engine** with no training capabilities
- The core library in [`crates/libsy/src/lib.rs`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/crates/libsy/src/lib.rs) implements `Algorithm::run_stream` and `Step` types exclusively for request routing
- No distributed training primitives exist in the codebase—no gradient sync, data loaders, or model updates
- Switchyard integrates with NVIDIA NeMo Relay and other inference endpoints as a **post-training deployment optimization layer**
- For distributed training, use PyTorch Distributed, DeepSpeed, or NVIDIA NeMo's training framework separately

## Frequently Asked Questions

### Does Switchyard support multi-GPU training?

No, Switchyard does not support multi-GPU training or any GPU computing for model training. The codebase contains no CUDA kernels, distributed data parallelism logic, or gradient aggregation code. Multi-GPU setups may run Switchyard's inference proxy, but the tool itself does not utilize GPUs for computation—it merely routes HTTP requests to external model endpoints that may or may not use GPU acceleration.

### Can Switchyard be used during the training phase of LLMs?

No, Switchyard cannot be used during training. It lacks the necessary components for forward/backward passes, loss calculation, and parameter updates. Switchyard operates on the assumption that models are already trained and deployed. You would complete training using a framework like PyTorch or NVIDIA NeMo, then deploy Switchyard as a smart proxy to route inference traffic to your trained models.

### What is the primary use case for Switchyard?

Switchyard's primary use case is **cost-optimized LLM inference routing**. It dynamically selects between models of different capabilities (e.g., routing simple queries to cheap, fast models and complex queries to expensive, powerful models). The tool excels in production environments where you want to minimize API costs while maintaining response quality by intelligently distributing requests across a fleet of pre-trained models.

### How does Switchyard integrate with NVIDIA NeMo?

Switchyard integrates with NVIDIA NeMo through the `switchyard-nemo-relay-plugin` crate, which allows Switchyard to function as a routing plugin within the NeMo Relay inference server. According to [`crates/switchyard-nemo-relay-plugin/README.md`](https://github.com/NVIDIA-NeMo/Switchyard/blob/main/crates/switchyard-nemo-relay-plugin/README.md), this integration enables NeMo Relay to use Switchyard's stage-router algorithms for intelligent model selection during inference, not during the model training pipeline.