NVIDIA released PAIR, Personal AI Router, in beta this week. The tool distributes AI inference requests across multiple machines on a local network, and it does so without requiring changes to the tools you already use. If you are running Ollama or LM Studio on several machines, PAIR sits in front of them and routes individual requests to whichever node is available.
The core problem PAIR solves is straightforward. Multi-agent AI workflows, where a lead agent dispatches subtasks to specialist sub-agents, generate multiple concurrent inference requests. On a single GPU, those requests queue up. The agent architecture assumes parallelism, but the hardware serializes the work. PAIR spreads the requests across available systems so each one executes on a separate node.
How the proxy works
PAIR acts as a transparent proxy. An agent sends a request to the local interface it expects, typically the Ollama or LM Studio endpoint. PAIR intercepts the request, identifies which model and engine it requires, selects an eligible node, and forwards the request. The node executes it from start to finish and sends the response back through PAIR. The agent sees a single connection throughout. It does not know which physical machine handled the request.
This design matters because it means existing agent harnesses, coding tools, and automation scripts do not need modification. You point them at PAIR instead of directly at Ollama, and the distribution happens automatically. The proxy handles model compatibility checks too, dispatching a task only to nodes where the required model or engine is known to work.
NVIDIA's demo combined Hermes Desktop, Ollama, and PAIR across an RTX Spark laptop, a DGX Spark, and an RTX 5090. Hermes decomposed a task into five independent specialist analyses, delegated them, reconciled the findings, and synthesized a final plan. PAIR distributed the five inference requests across the three machines. The result was roughly a 2x reduction in completion time compared to running everything on the single RTX Spark. NVIDIA cautions that this is not a performance guarantee. Results depend on workload parallelism, model choice, engine settings, hardware, network conditions, and node availability.
What PAIR does not do
NVIDIA is explicit about the boundaries. PAIR does not merge GPUs or pool VRAM into one larger accelerator. It distributes individual inference requests across separate systems. You cannot combine three 8GB cards to run a model that requires 24GB. Each request runs on a single node with that node's available memory.
This distinction generated confusion on social media. Some users interpreted PAIR as a way to share compute across the internet or to combine weaker hardware into something more capable. It is neither. It is a local network router for inference requests, scoped to machines you own and control.
The tool supports Windows 11, Linux, and macOS, with both x64 and arm64 architectures. Nodes running different operating systems can be paired together, as long as the model and engine are compatible with each target node.
The practical use case
Reddit user Vegetable-Warthog81 described running PAIR across three RTX 5090s with Qwen 3.8 27B through Ollama. The use case was repetitive, long-running inference tasks where keeping all GPUs busy mattered more than squeezing maximum tokens per second from any single one. The user reported that PAIR made distributing jobs across the three machines painless and that stability was better than expected for sustained workloads.
This matches the multi-agent pattern NVIDIA is targeting. A coding agent that spawns five sub-agents to analyze different parts of a codebase does not need them all to run on the same GPU. PAIR lets each sub-agent run on a separate machine, and the lead agent collects results as they arrive. The coordination overhead is minimal because the proxy handles placement transparently.
For developers running local models, the tool fills a gap that has existed since local inference became practical. Most people with multiple machines run models on one at a time, or manually decide which machine handles which task. PAIR automates that decision and does it per-request, which means load balances dynamically as nodes become available or busy.
The broader context
PAIR is not the only option for distributed inference. Petals and Mesh LLM both enable GPU compute sharing across a network of machines. Mesh LLM additionally supports splitting models too large for a single machine using its Skippy component. The difference is scope. Petals and Mesh LLM target multi-party or large-model scenarios. PAIR targets single-user, local-network setups where the goal is keeping multiple GPUs busy rather than combining them.
The release also reflects a shift in how NVIDIA is thinking about its hardware. The company has spent years marketing GPUs as monolithic accelerators for training and inference. PAIR acknowledges that many users have multiple smaller GPUs rather than one large one, and that the software layer needs to make that hardware usable without manual orchestration.
PAIR is available on GitHub. The getting started documentation walks through setup and configuration. For developers running local models across multiple machines, it is worth evaluating as a way to get more utilization out of hardware that is otherwise sitting idle during inference.