NVIDIA PAIR is a free, open-source virtual inference router that helps compatible computers on the same local network share independent AI inference workloads through one familiar local interface.
The Short Version
NVIDIA PAIR is a new open-source virtual inference router built to help people use several compatible computers on the same local network for local AI. Instead of sending every independent inference job to one machine, PAIR can discover participating systems, check which models and engines are available, and route work to an eligible computer. The result is a cleaner way to make more of the AI hardware already available at home or in a personal workspace.
A New Layer for Personal AI
Personal AI is quickly moving beyond one chat window and one model call at a time. Developers and power users are now running research agents, coding agents, organization tools and multiple local sessions at once. PAIR gives that growing activity a shared routing layer. Applications can continue using familiar local interfaces while PAIR handles where each independent request should run across the available machines.
PAIR Works With Familiar Local AI Engines
NVIDIA designed PAIR to work with existing local inference services rather than asking users to rebuild their software stack. The beta supports Ollama and LM Studio, two widely used tools for running models locally. PAIR sits in front of those engines and presents compatible proxy endpoints, giving applications a familiar connection while the routing layer manages placement across participating systems.
One Local Endpoint, Multiple Compute Options
From the application’s point of view, the workflow stays simple. A request arrives through the local endpoint, PAIR identifies the engine and model it needs, and then selects an eligible node. The application keeps seeing one connection while the routing happens behind the scenes. This is an elegant approach because it adds flexibility without forcing every agent or desktop tool to learn a completely new cluster interface.
Independent AI Jobs Can Run Across Different Machines
PAIR is especially useful when a workload creates several independent inference requests. A lead agent can assign research, coding, verification and summarization jobs to different subagents, and PAIR can place those requests on different available systems. That opens the door to more parallel local AI activity using hardware that might otherwise be sitting unused.
The Same Model Can Be Available on Several Nodes
Users can prepare the same model on multiple participating machines. When several nodes have that model available, PAIR has more eligible places to route incoming requests. This creates a simple way to expand service capacity for the models a user runs most often, especially in workflows where many agents may call the same model during one larger task.
Different Machines Can Host Different Models
PAIR also supports a more specialized setup. One computer can host one set of models while another holds a different set. The router checks model availability as part of its placement decision, allowing a personal AI network to become more organized. A workstation can be prepared for one class of workload while another system is ready for a different model or task.
PAIR Discovers Systems on the Local Network
The software uses local-network discovery through mDNS to find nearby compatible systems. Users can also add a node manually by IP address. Once the desired computers are paired, PAIR can treat them as part of the same trusted local group and keep track of which systems are currently ready to contribute AI capacity.
Pairing Is Designed to Be Simple
Connecting machines starts with a six-digit pairing PIN. After the pairing step, PAIR establishes certificate-based trust between cluster members. NVIDIA combines this straightforward setup flow with mutual TLS for most peer communication, giving the local cluster a secure foundation without turning setup into a complex infrastructure project.
The Scheduler Watches the State of Each Node
PAIR continuously tracks useful routing signals across participating systems. It checks whether a node is online and ready, whether the required inference engine is enabled, whether the requested model is present, the amount of queued work, and GPU utilization. These signals help the router choose an available destination for each new independent request.
Home Hardware Can Join and Leave Dynamically
One of PAIR’s most practical ideas is elastic participation. A compatible laptop, gaming PC, workstation or DGX Spark can contribute capacity while it is available and then simply leave the active pool when it is powered down or moved elsewhere. That makes PAIR a natural fit for real personal hardware, where devices are used for many different things throughout the day.
Support Starts With GeForce RTX 20 Series and Newer
NVIDIA says the PAIR beta supports systems with GeForce RTX 20 Series GPUs and newer. It also supports NVIDIA RTX PRO workstation GPUs based on Turing or newer architectures and NVIDIA DGX Spark. That gives the beta access to a broad range of existing RTX hardware rather than focusing only on the newest desktop systems.
Apple M4 and Newer Systems Are Included
The supported-hardware list also includes Apple M4 or newer silicon. That cross-platform support makes the concept especially interesting for users who already have a mixed collection of computers. PAIR can provide one routing layer across compatible systems even when those systems are not all built around the same desktop platform.
Windows, Linux and macOS Are Supported
The beta is available for supported Windows, Linux and macOS systems. NVIDIA provides both graphical and terminal interfaces, so PAIR can fit desktop workflows as well as more technical setups. The terminal option also makes it practical to include machines that are used primarily as compute nodes.
NVIDIA Demonstrated a Major Multi-Agent Speedup
NVIDIA demonstrated PAIR with a five-subagent workload using Hermes Desktop and Ollama. In the company’s test, the workload completed in 18 minutes on a single RTX Spark laptop. With a three-device PAIR cluster, it completed in 8 minutes and 48 seconds. The demo gives a concrete example of how parallel local AI requests can benefit when more compatible systems are available to serve them.
Multi-Agent Workflows Are a Natural Match
Agent systems naturally create the kind of workload PAIR is designed to organize. A lead agent can delegate separate tasks to specialized subagents, and those subagents can produce many model calls during one larger job. PAIR gives those independent calls more places to run, turning a collection of local computers into a more coordinated environment for agentic AI.
Research Agents Can Spread Work Across the Network
A research workflow can divide a topic into several branches, ask different subagents to collect evidence, and then bring the results together. With PAIR, those independent inference requests can be routed across multiple available systems. This is a strong example of how personal AI can move from a single-machine workflow toward a more flexible local compute network.
Coding Agents Can Benefit From More Available Capacity
Coding assistants increasingly combine planning, code generation, testing, review and documentation. When those activities are handled by several subagents, the number of local model calls can grow quickly. PAIR gives developers a way to bring additional computers into that workflow while keeping the application connected through a familiar local interface.
The Main PC Can Stay Focused on the User
PAIR can also help users make better use of a second PC or workstation while keeping the primary computer focused on interactive work. New inference jobs can be routed toward another eligible system with available capacity. For people who already own several capable machines, that makes local AI feel less tied to whichever computer happens to be in front of them.
Local-First Architecture Keeps the Experience Close to Home
NVIDIA designed PAIR around local-network operation. Participating systems discover one another on the LAN, and the routing layer is built to keep prompts, data and inference traffic within the user’s local environment when the local application and inference stack are configured that way. This fits neatly with the appeal of local AI: more direct control over where personal compute runs.
Mutual TLS Protects Most Peer Communication
After systems are paired, PAIR uses certificate trust and mutual TLS for most communication between cluster members. That gives the local compute group authenticated connections between participating nodes while keeping the overall setup approachable for personal use. Security is integrated into the pairing and routing design rather than being left as a separate manual project.
Getting Started Follows a Familiar Local-AI Flow
The setup process is straightforward: install PAIR on the participating computers, discover or add the systems, pair them, enable a supported inference engine, and prepare the models needed by the workload. Compatible applications can then connect through PAIR’s local endpoint. The structure feels close to a normal local-AI setup, with the routing layer adding access to more machines.
PAIR Can Help Install Engines and Prepare Models
NVIDIA’s getting-started documentation says PAIR can help install and start supported inference engines and initiate model downloads on participating nodes. That makes it more than a passive traffic layer. It can also help users prepare the machines that will provide local inference capacity, reducing some of the repetitive setup work across a multi-computer environment.
Open Source Gives Developers a Clear View of the Project
NVIDIA released Personal AI Router as an open-source project under the Apache License 2.0. Developers can inspect the code, study the architecture, report issues and contribute improvements. For a tool that coordinates AI work across several personal machines, that openness is valuable because the routing logic and project direction are visible to the community.
PAIR Creates a Home Inference Fabric
The clearest way to think about PAIR is as a home inference fabric. One local entry point can coordinate independent AI jobs across several available systems. Applications keep using familiar interfaces while the router handles placement. This creates a clean bridge between today’s local model tools and a future where personal AI regularly uses more than one computer.
Personal AI Is Expanding From One Session to Many
PAIR arrives at a useful moment. Local AI is expanding from one user talking to one model toward multiple agents and background sessions working at the same time. As that pattern grows, the ability to coordinate several computers becomes increasingly useful. PAIR gives NVIDIA users an early look at what a more distributed personal AI environment can feel like.
Who Will Get the Most From PAIR
PAIR is especially appealing for AI enthusiasts, developers, creators and power users who already own more than one capable computer. It also fits people experimenting with local research agents, coding agents, personal automation and multi-agent workflows. The more independent AI jobs a workflow creates, the more useful an organized pool of local compute can become.
Why This Launch Matters
PAIR makes spare local AI capacity easier to use. It connects familiar inference engines, familiar application interfaces and existing personal hardware through one open-source routing layer. That is a meaningful step because it makes multi-computer local AI feel more like a normal desktop capability and less like a specialized infrastructure project.
The Upgrade Feeling
NVIDIA PAIR has a simple but powerful idea behind it: the computers already around you can work together more intelligently for local AI. A gaming PC, workstation, laptop or DGX Spark can become part of the same personal inference network, with PAIR deciding where independent jobs should run. For multi-agent workflows, that turns existing hardware into a more flexible and coordinated AI environment — exactly the kind of upgrade that can change how personal compute feels in everyday use.
NVIDIA PAIR turns compatible computers on the same local network into a shared inference pool for AI apps and agents. It does not merge GPU memory or split one model across machines. Instead, PAIR discovers eligible Windows, Linux and macOS systems, tracks whether Ollama or LM Studio is ready, checks whether the requested model is present and routes each independent inference request to one available node. That architecture is especially useful for multi-agent workflows where several subagents make model calls at the same time. In NVIDIA’s configuration-specific Hermes demo, a three-device PAIR cluster completed a five-subagent workload in 8 minutes 48 seconds versus 18 minutes on one RTX Spark laptop. The more important shift is that local AI is starting to become distributed software: the gaming PC, workstation and laptop already in a home can act as separate workers behind one local endpoint.
Your Second PC Just Became an AI Worker
Local AI usually begins with one machine.
One GPU.
One inference server.
One model queue.
That works until the agent stops behaving like a chatbot.
A multi-agent system can create several model calls at once.
One subagent researches.
Another checks documents.
Another verifies an answer.
Another writes code.
Another summarizes the result.
If every request targets the same GPU, the jobs queue behind one another while another capable PC in the house may be doing nothing.
NVIDIA PAIR is designed around that mismatch.
It turns several compatible computers on one local network into a shared pool for independent AI inference jobs.
PAIR Was Announced at IFA 2026
NVIDIA announced Personal AI Router, or PAIR, on September 3, 2026 as part of its IFA push around local agents.
The software is available in beta for supported Windows, Linux and macOS systems.
NVIDIA describes it as a free, open-source virtual inference router.
PAIR works with Ollama and LM Studio at launch.
The goal is to let existing AI applications keep talking to a familiar local endpoint while PAIR decides which participating machine should actually run each request.
That is a software-routing problem more than a new model problem.
PAIR Is Not a New Inference Engine
This distinction is important.
PAIR does not replace Ollama.
It does not replace LM Studio.
It does not execute the model itself.
A supported inference engine still loads and runs the model on the selected computer.
PAIR sits in front of those engines.
It discovers machines.
Tracks their readiness.
Checks model availability.
Routes requests.
Then returns the response to the application that made the call.
The agent sees one local service.
PAIR handles placement behind it.
One Endpoint Hides Several Machines
The abstraction is simple.
An AI application connects to a local endpoint.
PAIR presents Ollama-compatible and OpenAI-compatible proxy interfaces.
The application sends a request as if it were talking to one local engine.
PAIR reads the engine and model requirements, chooses one eligible node, forwards the request and streams the answer back.
The application does not need to discover every machine itself.
That is the part that makes the cluster usable.
The complexity moves from the agent into the router.
The Devices Stay Separate
NVIDIA uses the phrase personal AI cluster.
That can create the wrong mental picture.
PAIR does not fuse several PCs into one giant computer.
Each device remains an independent machine.
Each GPU keeps its own memory.
Each inference engine keeps its own model files.
PAIR simply sends different independent requests to different systems.
That distinction defines what PAIR can accelerate and what it cannot.
PAIR Does Not Pool VRAM
Two 24 GB GPUs do not become one 48 GB GPU through PAIR.
NVIDIA explicitly says PAIR does not combine GPUs into a larger logical accelerator.
It does not pool VRAM.
If a model requires more memory than one machine can provide, PAIR cannot make that model fit by borrowing memory from another node.
The full model still has to fit on the individual computer selected to run the request.
That makes PAIR a routing layer, not distributed tensor-parallel inference.
PAIR Does Not Shard One Model Across Machines
The same rule applies to model execution.
PAIR does not split one inference request across several computers.
One request goes to one eligible node and stays there for its lifetime.
Another independent request can go to a different node.
That means the gain comes from concurrency.
Many calls at once.
Not one giant call spread across many GPUs.
This is why multi-agent workflows are the natural target.
Agents Create Exactly the Kind of Work PAIR Can Parallelize
A single chatbot conversation is often sequential.
Prompt.
Answer.
Next prompt.
An agentic workflow can be much wider.
A lead agent decomposes one task into several independent jobs.
Those jobs can run at the same time.
Each one may trigger its own inference request.
That is where a single local GPU becomes a queue.
PAIR gives the inference layer the same parallel structure as the agent workflow.
Several subagents can make progress simultaneously on different machines.
NVIDIA’s Demo Cut One Five-Agent Workload From 18 Minutes to 8:48
NVIDIA demonstrated PAIR with Hermes Desktop and Ollama.
Hermes created five specialist subagents for a synthetic household-inbox task.
On one RTX Spark laptop using Qwen 3.6 35B A3B, NVIDIA says the workload took 18 minutes on average.
A three-device PAIR cluster containing an RTX Spark laptop, a DGX Spark and an RTX 5090 desktop completed the same workload in 8 minutes 48 seconds on average.
That is a large difference.
It is also not a universal benchmark.
The 8:48 Result Has a Big Asterisk
NVIDIA explicitly labels the demonstration unofficial and configuration-specific.
The result depends on how parallel the workload is.
Which model is running.
The inference-engine configuration.
The hardware mix.
Network conditions.
Whether nodes are available.
A different task can scale differently.
A sequential workflow may gain almost nothing.
So the correct conclusion is not “PAIR makes AI twice as fast.”
The demo shows that routing independent calls across several ready devices can reduce queueing substantially when the workload exposes enough parallel work.
PAIR Watches Which Machines Are Actually Available
A home cluster is not a datacenter.
A laptop closes.
A gaming PC becomes busy.
A workstation goes to sleep.
A machine may have the right inference engine but not the requested model.
PAIR is designed around that instability.
It maintains a live view of the participating systems and decides whether each one can accept a new request.
The available pool can change while the cluster is running.
The Scheduler Checks More Than Whether a PC Is Online
NVIDIA says PAIR currently considers several factors for each request.
Is the paired node online and ready?
Is the required inference engine enabled?
Is the exact requested model present?
How many jobs are already active?
Is the GPU busy with another graphics-intensive workload?
Those signals let the router avoid sending work blindly.
A connected machine is not automatically an eligible machine.
Your Gaming PC Can Leave the Pool When You Need It
This is one of the more practical design choices.
A gaming PC may be an excellent AI worker while nobody is using it.
Then a game launches.
GPU utilization rises.
The machine should stop behaving like spare inference capacity.
PAIR can route new requests elsewhere when another system is more appropriate.
The same logic applies when a laptop sleeps or leaves the network.
Local AI capacity becomes elastic instead of permanently reserved.
The Requested Model Still Has to Exist Somewhere
PAIR cannot route a model request to a machine that cannot serve it.
The inference engine has to be running.
The model has to be available on that node.
The hardware has to have enough memory to load it.
That creates an important operational detail.
If only one computer has a particular model, every request for that model will still converge on that one machine.
The cluster only becomes useful for that workload when several eligible nodes can serve the requests.
Every Node Does Not Need the Same Model Library
The opposite is also true.
NVIDIA says machines in a PAIR cluster do not have to hold identical model collections.
One system can host one model.
Another can host a different model.
PAIR can route requests according to where the requested model exists.
Replicating the same model across several nodes increases the number of machines that can serve that request.
Different model placement can turn the home cluster into a small heterogeneous inference pool.
That Makes Storage Part of Local AI Scaling
Distributed inference sounds like a GPU story.
It is also a storage story.
If the same large model is copied to three machines so all three can answer requests, the model consumes storage three times.
Local agents may use several models.
Embedding models.
Language models.
Vision models.
Rerankers.
The more redundancy a user wants across the cluster, the more local disk capacity is consumed.
PAIR does not eliminate that trade-off.
It makes the trade-off manageable through routing.
PAIR Supports RTX 20 Series and Newer
NVIDIA says the beta supports GeForce RTX 20 Series GPUs and newer.
RTX PRO workstation GPUs using Turing architecture and newer are also included.
DGX Spark is supported.
That gives PAIR access to hardware accumulated across several generations rather than requiring only the latest flagship card.
A household may already own much of the compute before installing the software.
That is central to the pitch:
use the machines that are already there.
Apple M4 and Newer Can Join Too
The most interesting compatibility decision may be Apple silicon.
NVIDIA says PAIR supports Macs with M4 or newer silicon.
That means the personal cluster is not limited to NVIDIA-only client hardware.
A Windows RTX desktop and a supported Mac can participate in the same routing system.
The inference engine and model still have to work on the node.
But the router itself is designed around mixed operating systems and mixed hardware.
That makes PAIR closer to a software-defined home inference layer than an RTX-only cluster manager.
Windows, Linux and macOS Nodes Can Mix
PAIR supports Windows 11, Linux and macOS.
The open-source repository says x64 and arm64 are supported across the three operating-system families, with Windows on Arm marked experimental.
Nodes using different operating systems can be paired together.
That flexibility matters because personal hardware is messy.
One person may have a gaming desktop on Windows, a Linux workstation and a MacBook.
PAIR is designed to treat that mixture as potential inference capacity rather than forcing the user to standardize the entire household.
Ollama and LM Studio Are the First Backends
At launch, PAIR supports Ollama and LM Studio.
That choice lowers integration friction.
Both are already widely used for local model inference.
Applications that already know how to talk to those local interfaces do not need a custom distributed-computing API.
PAIR proxies the familiar interface instead.
NVIDIA says agent harness changes are not required for compatible workflows.
That is strategically important.
A new router is much easier to adopt when users do not also have to replace the tools around it.
The Router Can Discover Machines Automatically
PAIR uses local-network discovery through mDNS to find nearby participating systems.
A node can also be added by IP address.
The user then approves a pairing request.
The goal is to make adding compute closer to connecting a local device than configuring a traditional compute cluster.
That matters because the target environment is not an enterprise datacenter run by cluster administrators.
It is a home, studio or small workstation network.
The Pairing Layer Uses mTLS
NVIDIA says node-to-node communication is blocked until pairing is established.
After pairing, communications use mutual TLS with generated certificates.
That provides encrypted traffic and authentication between cluster members.
The security model still depends on the local environment.
NVIDIA’s repository explicitly warns users to read the security documentation before deploying PAIR on an untrusted or shared network.
A local network is not automatically a trusted network.
Local Does Not Automatically Mean Every Byte Stays Private
NVIDIA describes PAIR as designed for private local inference.
Prompts, files and agent context can remain on the home network rather than going to a cloud inference service.
The open-source repository adds an important qualifier.
That statement holds when the configured client, model source, inference engine and participating nodes are all local.
An agent can still choose to call a cloud service.
An application can still transmit data elsewhere.
PAIR keeps its routing local.
It cannot guarantee the behavior of every other component in the workflow.
No Internet Is Required for Operation
NVIDIA’s PAIR product page says internet connectivity is not required for operation.
Internet access is required for downloading models.
Once the needed software and model files are present, the routing layer can operate across the local network.
That matters for privacy.
It also matters for resilience.
A local agent workflow can continue using local compute even when external connectivity is unavailable, as long as the application itself does not depend on cloud services.
The Best Workload Is Wide, Not Long
PAIR helps when several independent inference calls exist at the same time.
It helps much less when one long model call dominates the task.
If step two cannot start until step one finishes, another idle GPU has nothing useful to do.
This is basic parallel computing.
The workload has to expose parallelism before a router can exploit it.
Multi-agent systems happen to create that parallelism naturally.
That is why PAIR arrived at the same moment local agents are becoming more ambitious.
The Scheduler Is Still Simple
The current PAIR beta should not be mistaken for a mature datacenter scheduler.
NVIDIA’s repository says the shipped scheduling policy combines queued work with a coarse, smoothed GPU-utilization signal.
It does not yet consider every useful variable.
GPU model.
Available memory.
Model warmness.
Estimated request cost.
NVIDIA says those are areas it may improve.
That means today’s version can route intelligently enough to be useful while still leaving substantial room for better scheduling.
Mixed Hardware Is Supported — but Similar Machines May Be Easier
PAIR can connect heterogeneous systems.
That does not mean every mixed cluster will balance perfectly.
A small laptop GPU and a large workstation GPU can have very different inference speeds.
A Mac and an RTX desktop may use different runtime paths.
The current scheduler does not fully model every performance difference.
NVIDIA’s own repository says PAIR can be a better fit for similar machines than a highly mixed cluster under the current policy.
The hardware support is broad.
The scheduling intelligence is still evolving.
This Is More Like a Load Balancer Than a Supercomputer
The simplest analogy is a load balancer.
Requests arrive.
The router looks at available workers.
One worker receives each request.
Other requests can go to other workers.
The system becomes more capable under concurrent demand because work is spread across several machines.
PAIR is not trying to recreate an HPC fabric inside the house.
It is making local inference routing simple enough that several personal computers can behave like a small service pool.
The Agent Does Not Need to Know Which Computer Answered
This abstraction is what makes distributed local AI practical.
The agent asks for a model response.
PAIR decides where it runs.
The response returns through the same interface.
NVIDIA exposes Jobs and metrics views so the user can inspect which node actually handled each request.
But the agent itself does not have to carry cluster topology.
That separation allows the agent developer to focus on task decomposition while the router handles resource placement.
The Source Code Is Public Under Apache 2.0
NVIDIA has published PAIR on GitHub.
The repository is licensed under Apache License 2.0.
Developers can inspect the implementation, report issues and contribute to discovery, pairing, routing, engine integration and the user experience.
That matters for a tool sitting between private local data and inference engines.
The routing layer is not an opaque cloud service.
Users and developers can examine how the system is built.
Third-party inference engines and models can still carry their own separate licenses and terms.
PAIR Turns Old Hardware Into Capacity Instead of E-Waste — Sometimes
A previous-generation RTX machine may no longer be the user’s main PC.
PAIR gives compatible hardware another possible role.
Serve local inference when idle.
That does not mean keeping every old computer powered on is automatically efficient.
Electricity use still matters.
Older hardware may perform poorly per watt.
The practical value depends on how often the extra capacity is needed.
But the architecture creates an option that did not exist in the normal one-PC local-AI model:
reuse existing machines as temporary workers.
The Cloud Is Still Better for Some Jobs
PAIR is not an argument that every AI workload should move home.
Cloud systems offer larger accelerators.
Large memory pools.
High-bandwidth interconnects.
Managed availability.
Frontier models that may not fit on local machines.
The local cluster solves a different problem.
Private data.
Existing hardware.
No per-token local inference charge.
Low network dependency.
Parallel agent workloads that fit on the available nodes.
The likely future is hybrid.
Local when local makes sense.
Cloud when scale wins.
PAIR Could Change How People Buy Their Next PC
The most interesting long-term effect may be behavioral.
Today, a laptop and desktop are usually treated as separate computers.
PAIR gives them a second identity.
Members of one personal compute pool.
That changes the value of idle hardware.
A workstation in another room is no longer disconnected from the agent running on the main PC.
A supported Mac can contribute.
A gaming desktop can contribute when not gaming.
The home network becomes part of the AI architecture.
This Is the Software Layer RTX Spark Was Missing
RTX Spark gives NVIDIA a powerful local-AI hardware platform with large unified memory and strong inference capability.
PAIR solves a different layer.
What happens when a user owns more than one capable device?
Instead of treating each computer as an isolated AI island, PAIR lets the machines contribute to one routing pool.
That makes the local-AI story larger than one expensive laptop or desktop.
The unit of compute starts to become the network.
What NVIDIA Has Actually Confirmed
NVIDIA announced PAIR on September 3, 2026.
PAIR is a free, open-source virtual inference router available in beta.
It supports compatible Windows, Linux and macOS systems.
At launch it works with Ollama and LM Studio.
Supported hardware includes GeForce RTX 20 Series and newer, RTX PRO workstation GPUs, DGX Spark and Apple M4 or newer silicon.
PAIR discovers and pairs systems on the local network, tracks node readiness and routes each independent inference request to one eligible machine.
It does not pool GPU memory or shard one request across several machines.
NVIDIA’s Hermes demonstration showed 18 minutes on one RTX Spark laptop versus 8 minutes 48 seconds on a three-device PAIR cluster for that specific five-subagent configuration.
The GitHub project is licensed under Apache 2.0.
What We Should Not Claim
We should not say two GPUs become one larger GPU.
PAIR does not pool VRAM.
We should not say one large model can be split across several PCs.
PAIR does not shard a single inference request.
We should not say the demo proves a universal two-times speedup.
NVIDIA explicitly says it is configuration-specific and unofficial.
We should not say every connected machine can serve every request.
The engine, exact model and sufficient memory have to be available.
We should not say local routing guarantees total privacy if the agent or another component still calls cloud services.
And we should not describe the current scheduler as a datacenter-grade optimizer.
NVIDIA says it still uses a relatively simple policy.
The Bigger Shift Is That Personal AI Is Becoming Distributed
The first local-AI wave asked whether one PC could run a useful model.
The next question is what happens when several machines can.
PAIR’s answer is not to weld the hardware together.
It is to make the software smart enough to route around the house.
One laptop handles one subagent.
A desktop handles another.
A workstation picks up a third request.
The agent sees one local endpoint.
The user sees several machines finally doing something useful at the same time.
That is a subtle shift.
Local AI stops being a property of one PC.
It becomes a property of the network.