Use one GPU when one GPU is enough.
Send smaller models and independent jobs to the best available workstation instead of tying up the entire pool. Most office AI work should end up here.
OfficeGPU is building a managed private AI service for small professional offices. It uses the RTX workstations you already own—routing smaller workloads to one GPU and pooling several machines when a model needs more GPU memory than any single machine has.
Build your office below. This runs the same memory arithmetic our placement planner is specified to use, decides ROUTE or POOL, and shows you the working. It deliberately does not quote tokens per second, because we have not measured your configuration yet.
Mark a machine IN USE to simulate someone working on it — Revit, Rhino, Enscape, a render. Its GPU then leaves the borrowable pool, which is how OfficeGPU is designed to behave.
Most small offices already own powerful GPUs. They sit inside individual workstations, often underused after hours and isolated from each other.
We are building the software layer that makes that capacity usable as one managed local AI service.
OfficeGPU is designed for offices that want private local AI without buying and operating a dedicated AI server cluster.
Send smaller models and independent jobs to the best available workstation instead of tying up the entire pool. Most office AI work should end up here.
Distribute a model across several workstations when it needs more GPU memory than any single machine can provide—loaded in advance, not assembled while someone waits.
OfficeGPU is designed to decide whether a workload belongs on one machine or a warm pooled deployment—so nobody has to understand tensor parallelism to use it.
Reserved windows, availability policies and user-activity guards are planned so that the architect at PC-07 never loses their GPU to an AI job.
Network profiling per interface path and benchmark-driven readiness are core to the design—because distributed inference is only useful when the connection is good enough.
Applications talk to OfficeGPU. OfficeGPU handles the complexity underneath: available nodes, models, network paths, routing, pooling and deployment state.
The product is being designed around office-owned hardware and local-network operation, with secure node enrollment and authenticated client access.
Large pooled models are planned to be loaded ahead of time—not assembled when a user sends a request.
Pool readiness will be derived from real benchmarks across 1, 2.5 and 10 GbE rather than hard-coded marketing claims.
A product for small professional offices is defined as much by its limits as its features. Ours has a hard edge: the computers your company owns, on the network your company controls.
No peer-to-peer network of unknown machines, no relays, no marketplace for idle GPUs. The pool is your own hardware, enrolled by your own administrator.
No Kubernetes, no Ray cluster, no InfiniBand, no NCCL tuning. If it needs an AI infrastructure engineer to operate, it is not our product.
Windows workstations, ordinary Ethernet, a signed installer, a console an IT generalist can read, and an endpoint that behaves like the APIs your tools already speak.
Windows 11, NVIDIA RTX, wired LAN, text models, two to four machines. Everything else waits until that works properly.
The technical primitive—distributed inference—already exists in open source. Anyone can split a model across two machines with enough scripting. Our focus is the layer a real office needs around it.
Workstation-aware orchestration
Know what capacity is actually borrowable, not just installed.
Benchmark-driven qualification
Measure GPUs, network paths and model placements before calling a pool ready.
Office-grade operations
Managed deployments, recovery, access control, scheduling and a Windows-first installer.
Focused scope
A product for small offices—not a data-center stack, public swarm or GPU marketplace.
We would rather point you at primary sources than describe a market opportunity in adjectives.
NVIDIA’s own local AI router documentation states that it routes a request to a single node and does not pool GPU memory or make several GPUs act as one larger GPU. Adjacent product, different job.
docs.nvidia.com ↗EXO’s published platform support lists Apple Silicon as its tested tier, with Windows CUDA in longer-term work. The offices we care about are Windows and NVIDIA today.
github.com ↗llama.cpp’s own RPC documentation calls the distributed backend proof-of-concept, fragile and insecure, and says not to expose it on an open network. Turning that into something an office can run safely is the work.
github.com ↗Our initial focus is the kind of business that already owns several high-end Windows workstations but does not operate a dedicated AI infrastructure team.
Ask if your office is a fit ↗OfficeGPU is in development. Our first technical gate is intentionally narrow: prove that two ordinary Windows RTX workstations can run a useful model that does not fit on either GPU alone, at interactive speed, over office Ethernet—and clearly beat the practical single-PC alternative for the right workloads.
ArchitectureProduct scope and V0/V1 plan defined
2-PC proofCapacity, speed and network benchmarking
OfficeGPU alphaAgent, manager, gateway and console
Design-partner pilotReal office deployment and workflow validation
A model that does not fit on either GPU alone must load fully on the GPUs of two Windows workstations and answer 0 prompts in a row without an error.
Pooled output must be interactive and clearly better than the same office’s best single machine spilling into system RAM—in speed, quality, context or concurrency.
The result has to hold on wiring offices actually have—0, 0 or 0 GbE—not only on a direct 10 GbE cable in a lab.
No. The GPUs remain separate. PoolBridge is designed to distribute models and inference work across machines, exposing their aggregate available GPU memory to workloads that can be partitioned.
That is the constraint we design around. Pooled deployments are planned to run inside reserved windows and on machines that are not in use, with user-activity guards and a drain step when a window ends. A busy workstation should simply not be part of the pool.
Our product direction is local-first: inference is designed to run on office-owned workstations over the local network. External services may be added only when explicitly configured by the customer.
Because we have not measured enough configurations to state one honestly. Capacity is arithmetic and we show it openly in the planner above. Speed depends on your GPUs, network path, model and context, and we would rather publish real benchmark data—including results that disappoint us—than a marketing figure.
No. OfficeGPU is being designed as its own managed compute layer. It may integrate with adjacent local-AI tools over time rather than requiring customers to abandon them.
The architecture includes an API compatibility layer. OpenAI-compatible interfaces are the first implementation target; additional adapters can be added later without redesigning PoolBridge. We plan to publish a compatibility matrix generated from automated tests rather than claiming parity.
We are preparing the technical proof and alpha. If your office has multiple Windows RTX workstations and you are interested in becoming a design partner, contact us.
We want to talk with small professional firms that care about private local AI and already own the hardware.