remote.network · private beta
Point any OpenAI-compatible client at one address. Your request goes to a real machine, a Mac Studio in a closet or a gaming PC under a desk, and the model runs right there while the answer streams back over a direct connection the network punched through NAT. No GPU cloud. No port forwarding. Your hardware, your models.
This page loads no fonts, no analytics and no third-party scripts.
The problem
Every house and office has a fast machine idling. Every cloud invoice is renting that same silicon back.
Mac Studios, gaming rigs with 16 GB VRAM, towers that stay on overnight. All of them run 4B to 30B parameter models comfortably, and most of the day they do nothing. Meanwhile their owners pay per token to rent the same silicon back.
A laptop running Ollama serves exactly one laptop. The moment a second person, device or office is involved, someone has to become the operator: open ports, hand out addresses, keep track of who is serving what.
NAT traversal, discovery, scheduling, failover, metering, trust between machines that have never met. None of it is model code. All of it is the reason "just run it locally" never turned into "run it as a fleet".
How it works
Nodes dial out and stay reachable through whatever NAT they sit behind. The router matches each request to a machine that can actually serve it.
One static agent detects the hardware, probes whatever inference stack is already installed (Ollama, llama.cpp, vLLM, anything OpenAI-shaped) and connects out with a single WebSocket. Home NAT is the normal case.
Every probed model becomes a service card with modality, context, size, measured tok/s and TTFT, published to the router's directory. Network-standard models keep their canonical id; anything else publishes pinned to the node that has it.
Per request the router ranks the live nodes: best value, cheapest or fastest, weighted by reputation earned from real outcomes. If a node dies before the first token, the request moves to the next candidate and nobody notices.
Node and router classify the NAT together, then the router dials back through the hole: direct QUIC with identity-bound certificates. Cone NATs get a direct path. Symmetric ones fall back to the relay, and the ledger records which path every request took.
The model runs on the node's own silicon and tokens stream back as server-sent events. Standard chat completions, standard embeddings, standard model listing. Existing SDKs work after changing one URL.
Every request is metered to the token into a ledger, and earnings accrue to the node that served it. A node that shuts down drains its in-flight streams first. A node that misbehaves stops getting work.
$ remote node start --router wss://spine.example.net/node/v1/connect hardware detected Apple M2 ×8 · 24 GB unified · Metal 4 backends probed Ollama @ localhost:11434 · 32 models card built google/gemma4-26b-a4b-it ← gemma4:26b-a4b-it-qat bench done ttft 705 ms · 26.5 tok/s punch observed nat=cone → direct QUIC armed serving 31 models · session stable $ curl https://spine.example.net/v1/chat/completions \ -H "Authorization: Bearer rn_sk_…" \ -d '{"model":"qwen3:4b","messages":[{"role":"user","content":"hi"}],"stream":true}' data: {"choices":[{"delta":{"content":"Hello"}}]} # routed to whichever node was cheapest and awake
Capabilities
Chat completions, embeddings and model listing on the paths every SDK already expects. Change the base URL, keep the client.
Hole-punched QUIC between router and node. No port forwarding, no public IP, no VPN. UDP probes and dials ride the same socket the data uses.
Agents only dial out. A node behind the most aggressive CGNAT still serves. The NAT type decides which path is used, nothing else.
Cards carry what matters: modality, context window, VRAM cost, measured tok/s and TTFT, price per million. Canonical ids where they exist, node-pinned ids where they don't.
The scheduler keeps candidates. A node that dies mid-handoff costs the request nothing; a stream already flowing drains before the node leaves.
Scores weighted from real outcomes: heartbeats kept, requests served, usage reported correctly. Misbehaviour quarantines a node; clean behaviour brings it back.
Input and output tokens land in a ledger for every request, with the routing path and request id. Earnings accrue per node per hour window. You can check the numbers yourself.
Key management sits behind an admin token. Prometheus metrics and pprof are exposed. Request ids travel end to end. If a router changes its key, every node that pinned the old one refuses to connect.
Running it
All you install is one static agent per machine. The routers, the public half of the network, are run by remote.network during the beta and by partners as it spreads. Peer-to-peer data paths, one broker.
The routers
During the beta, remote.network operates the routers: the one address clients dial, the one place with public ports. The router brokers connections and relays only when no direct path can be punched. Inference goes machine to machine wherever a hole can be punched. Later, partners host their own routers from the same static binary. The protocol was designed for that.
The fleet
Macs, Windows boxes, Linux towers. The agent detects their hardware and serves whatever inference stack is installed: Ollama, llama.cpp, vLLM, or the zero-setup path that downloads a pinned open-weights model and supervises it for you.
macOS, windows, linux, on amd64 and arm64On each machine
$ remote node start --skip-bench \ --router wss://spine.example.net/node/v1/connect
Why the network can be trusted
Every node holds an Ed25519 identity and signs the router's challenge. The router presents its public key on first contact and the node pins it from then on. If the router ever changes its key, nodes refuse to connect and say so.
The direct path is QUIC with identity-bound certificates. When a symmetric NAT makes punching impossible, traffic falls back to the relay. Every ledger row records which path it took, so "usually direct" is a number you can check.
Consumer keys pick a routing policy and die on revocation. The surface that mints them sits behind a router-held admin token. Keys are shown once, so a leaked database is not a leaked fleet.
Request ids travel from client through router to node and into the logs. The ledger keeps path, tokens, attempts and status for every request. When something misbehaves, you can find the exact request.
Who it is for
Private beta
The beta runs on real machines in real homes and offices. That is the point. Tell us what hardware you would connect and we send an invite and a router address. We answer personally.
Or write directly to ping@remote.network. We keep the address and nothing else.