AI agents are learning to do more by working together. A lead agent can break a complex task into smaller jobs and assign those jobs to specialized subagents. Additionally, users are starting to run multiple agent sessions at the same time. Multi-agent workflows for accomplishing complex tasks are also becoming more common.
This breadth-first approach can improve the speed of task completion and improve the quality of responses, but it can also bottleneck the system as many requests are sent to the GPU simultaneously.
NVIDIA Personal AI Router (PAIR) leverages your local hardware to relieve this multi-agent and subagent bottleneck. PAIR routes each independent inference request to an available system on the home network. It works with familiar local inference services, including Ollama and LM Studio, so users can expand the compute available to an agent without redesigning the agent itself. No agent harness changes are necessary.
The NVIDIA PAIR beta is available for supported Windows, macOS, and Linux systems through graphical and terminal interfaces. It supports compatible systems with NVIDIA GeForce RTX 20 Series GPUs and newer, NVIDIA RTX PRO workstation GPUs (Turing architecture and newer), as well as NVIDIA DGX Spark and Apple M4+ silicon.
What is NVIDIA PAIR? #
NVIDIA PAIR is a virtual inference router that maximizes the AI compute in your home. It’s not a new inference engine. Ollama or LM Studio still runs the model on a selected machine. PAIR discovers participating systems, tracks whether each system is ready for a request, schedules independent jobs, and returns each response to the application that originated it.
Agents can send a request through the familiar local interface it expects. PAIR receives the request through its proxy, identifies its engine and model requirements, and selects one eligible node. That node executes the request from start to finish and sends the response back through PAIR. The agent continues to see one connection while PAIR handles placement behind it. Features include:
No new API: PAIR proxies compatible Ollama and LM Studio interfaces rather than asking every agent harness to integrate with a new cluster API.Elastic clients: Compatible systems can contribute capacity when available and drop away when needed such as powering down or hibernating the system.Local control: PAIR is designed to keep prompts, data, and inference traffic on the user’s existing local network.
How does PAIR solve the multi-agent local inference problem? #
Consider an AI prosumer running a local agent on a primary NVIDIA RTX AI PC. The agent receives a research, coding, or personal organization task and divides it among several subagents. Each worker explores a bounded part of the problem while other workers verify evidence or assemble the result.
From the user’s perspective, this is one task. At the inference layer, it can become dozens of independent model calls. If every call targets one local engine, they compete for the same execution slots. The queue grows, and the primary PC stays occupied even though an RTX PRO workstation, laptop, or DGX Spark elsewhere on the network may have compatible capacity available. PAIR allows the inference layer to widen with the agent. Some subagent requests can run on the primary PC while others run on additional paired nodes. When the workload has enough independent work, using more ready systems can reduce queueing and improve end-to-end completion time.
It can keep the primary PC focused on graphics-intensive gaming, content creation, or other interactive work while distributing inference to other nodes.
This is workload-level concurrency. PAIR does not make one inference request run across several GPUs. Every request is assigned to one eligible node and remains there for its lifetime.
Leveraging the elasticity of home AI clusters
A home AI cluster is not a miniature data center. Dedicated clusters are typically built around systems that remain powered, consistently configured, and continuously available. Home hardware is dynamic. A gaming PC may become busy playing a game. A laptop may sleep, close, or leave the network. A workstation may have the requested model while another machine does not. An inference engine can be stopped, or the user can reclaim a GPU for a foreground application.
PAIR is designed around those changing conditions. It can discover local systems with mDNS, pair supported devices on the private network, and maintain a live view of which nodes can accept new work. Client nodes can join the available pool when ready and drop away when needed without turning the home into a dedicated, always-on inference installation.
For each new request, PAIR considers various factors, including:
-
Whether a paired node is online and ready
-
Whether a supported inference engine is enabled
-
Whether the exact requested model is present
-
The current node and engine workload, including active jobs
-
The existing GPU utilization (whether there is a graphics intensive app or tool running)
PAIR does not depend on every system being identical or permanently available. It schedules inference requests and manages the cluster around how the systems are used in everyday life.
Demo: Hermes five-subagent scenario
This demonstration features PAIR with Hermes Desktop, which creates the subagent workload, and Ollama, which executes the model on each selected node. The task asks Hermes to analyze a synthetic household inbox and produce a trustworthy Sunday Reset plan—what must happen tonight, this week, later, or not at all—with evidence for each material conclusion.
For the five-subagent run, Hermes creates five specialists to review independent parts of the evidence, reconcile conflicts and return a consolidated plan. Hermes owns decomposition, delegation and synthesis. PAIR owns inference routing. Ollama executes each request on the node PAIR selects.
Using Qwen 3.6 35B A3B on one [NVIDIA RTX Spark](https://www.nvidia.com/en-us/products/rtx-spark/) laptop, the same five-subagent workload took 18 minutes to complete on average. In comparison, a three-device PAIR cluster containing an RTX Spark laptop, a DGX Spark, and an RTX 5090 took 8 minutes and 48 seconds to complete on average. Note that this is an unofficial, configuration-specific demo, not a general benchmark or a promise of linear scaling.
Unofficial, configuration-specific demonstration. Results depend on workload parallelism, model, engine settings, hardware, network, and node availability. This is not a universal benchmark.
The Jobs view in PAIR is the ground truth for where inference ran. Hermes agent count and PAIR job count are different measurements because one agent can generate multiple model requests. Multinode execution should be claimed only when PAIR telemetry shows jobs running on more than one eligible node.
How does NVIDIA PAIR work? #
This section provides a step-by-step detailed explanation of how NVIDIA PAIR works.
Using local-network discovery to find nearby systems
After PAIR is installed on each compatible Windows, macOS, or Linux system, it uses local-network discovery (mDNS) to find nearby systems automatically. A node can also be added by IP address when needed. The user approves a secure pairing request to create the trusted set of local nodes PAIR can consider.
All node to node communication is blocked until the secure connection and pairing is established. Once the connection is made, communications are secured with MTLS and generated certificates so that the communications between the nodes stay private on the network.
Preparing inference engines and models
Each participating node runs a supported local inference engine: Ollama or LM Studio. PAIR can help install an engine and initiate model downloads on paired systems, reducing the work required to prepare several machines. A node becomes eligible for a request only when the required engine is enabled and the exact requested model is available there.
However, models do not have to be identical across each node in the cluster. Different systems can host different models, and PAIR can route according to model location. the same model tag on more nodes simply gives the scheduler a larger eligible pool of nodes for that request.
Proxying the compatible local interface
A compatible application sends an Ollama-compatible or LM Studio-compatible request through the local endpoint proxied by PAIR. Agent harnesses can continue using the interface they already understand instead of discovering and integrating with every machine independently. Applications that expose a configurable base URL can continue to point at their Ollama or LM Studio respective endpoints.
PAIR proxies the request by taking over the default port that Ollama and LM Studio use for their services. If the agent harness is using a different port, the proxy port can be configured in the PAIR engine settings.
PAIR inspects the request’s engine and model requirements, then passes those requirements to the router. This separation is central to the design: the agent decides what work to request, while PAIR decides where eligible work should run.
Scheduling one eligible node
The scheduler filters paired systems using current information about readiness, supported engine state, requested-model presence and job load. It selects one eligible node, and the PAIR router on that system passes the request to the local inference engine. Independent calls from other subagents can be assigned to other ready nodes at the same time.
Returning the response and making routing visible
The selected engine executes the request, and PAIR streams the response back through the same local interface to the originating application. The Jobs and metrics views show which node handled each routed request, making placement observable.
What workloads benefit most from PAIR? #
PAIR is most useful for workloads that expose several independent requests at the same time, including multiagent applications and concurrent local AI tools.
For those workloads, PAIR can:
- Route independent jobs across ready systems on the local network
- Reduce queueing when several requests would otherwise wait behind one local engine
- Improve completion time for a suitably parallel workload in a compatible configuration
- Help free the primary PC for gaming, creation, or other interactive tasks
- Keep the application workflow familiar and local-first
PAIR does not:
- Merge GPUs or pool VRAM into one larger accelerator
- Shard a single model or split one inference request across machines
Highly sequential tasks, workloads dominated by one long model call, or configurations in which only one node has the requested model may see less benefit. Measure the workload that matters using end-to-end completion time, queueing, output quality and observed routing on the actual systems in use.
Get started with NVIDIA PAIR #
PAIR brings a cluster-like experience to the dynamic NVIDIA systems already in the home while keeping the local inference workflow familiar. Follow the steps below to get started:
Download the NVIDIA PAIR betafor a supported Windows, macOS, or Linux system.- Install PAIR on the NVIDIA RTX PCs, NVIDIA RTX PRO workstations, or NVIDIA DGX Spark systems to include.
- Discover and securely pair the systems on the local network.
- Enable Ollama or LM Studio and download or place the required models on eligible nodes.
- Run a compatible agent on a system with PAIR installed that uses Ollama or LM Studio.
The NVIDIA PAIR project is open source. Developers can inspect the code, report issues, and contribute improvements to discovery, pairing, routing, engine integration, models, endpoints and the user experience.