Overview: gpuroute, compute for your agents
Map: datacenters, frontier AI sites, undersea cables and live orbital compute, with the world_compute agent call
Start: connect your agent, pool spare machines, ask
Compute: everything your agent can reach and how busy it is right now
Spend: allowance, approvals and provider setup
Jobs: workloads on shared nodes, local GPU and Modal H100
Log: append-only audit of every launch, refusal and settlement

Inspiration

Coding agents can write a fine-tuning script in seconds. The moment it needs a GPU, a human has to step back in: figure out how much VRAM it needs, compare a dozen clouds, and decide whether to trust the agent with a cloud account. We researched where people actually struggle:

Sizing training "by inference intuition is wrong by an order of magnitude," which leads to out-of-memory crashes and restarts
Every provider's agent tooling (RunPod MCP, Hugging Face Jobs, Modal skills) covers only its own platform
There's "no mature tool that enforces per-job GPU budgets for coding agents," and forgotten GPUs keep billing ($400 over a weekend for an idle H100)
85% of surveyed academic NLP researchers have $0 cloud budget, while free compute (local GPUs, Kaggle, Colab, free credits) is scattered

What it does

gpuroute is an MCP server + CLI + local dashboard:

gpuroute share: one command turns any machine (a teammate's laptop, a gaming PC, a lab box) into a node. The owner's rules are enforced on their machine: idle-only (read from the GPU driver), a minutes cap, one job at a time, and every job printed in their terminal
compute_map: every resource the agent can use and how busy it is right now: this machine, shared nodes, Modal, the live Vast.ai spare-GPU market (1,650 GPUs listed today), Kaggle and Colab
run_workload: run ANY Python workload (transcription, embeddings, image generation, rendering, batch inference) with its own deps (installed by uv) and input files on the best idle node; outputs come back
orbital_offers / book_orbital: a marketplace for satellite compute (GPU time while the satellite is sunlit) and ground-station relay passes to downlink results, across operators, timed from live orbits
run_workload(target="modal:H100"): the agent picks the GPU (T4 → B200), and the budget becomes the provider's hard timeout
Internet compute pool: gpuroute hub deploys a relay; anyone, anywhere, joins a spare machine with one command (gpuroute share --pool). Nodes connect outbound, so no LAN or port forwarding, and they appear in compute_map automatically
world_compute: the map as agent context: datacenters near a city, frontier AI sites by owner, undersea, and live orbital compute (e.g. for data-residency questions)
read_output: the agent reads results without extra file permissions
estimate_job: VRAM needed (weights/optimizer, activations, overhead) and time on 16 GPUs, before renting anything
quote_job: ranks every way to run the job by what you'd actually pay: your own Mac/GPU ($0, private), Kaggle, Colab, Modal (free credits), and the live Vast.ai GPU market
launch_job: runs a LoRA fine-tune under a hard budget, or waits for human approval above a threshold
job_status: step, loss curve, cost so far, artifact path. No SSH babysitting
connect_provider: the agent sets up the cloud GPU itself and hands the human only the steps that must be theirs (sign-in, payment method), already opened in the browser
free_inference_models: checks OpenRouter for models that are free right now, because the cheapest fine-tune is the one you don't need

How we built it

Python. The MCP Python SDK for the agent interface, rich for the CLI, a stdlib HTTP server + vanilla JS for the dashboard, transformers + peft for training. Launch adapters for local Apple MPS/CUDA and Modal.

The budget is enforced in three layers:

Policy: per-job cap, monthly allowance, budget ≥ estimate
Infrastructure: Modal's function timeout = budget ÷ price per second, so the provider kills the container even if the agent stops polling. Local jobs have a watchdog
Settlement: actual GPU-seconds × price goes into an append-only audit log

Agents get an allowance, never credentials. There is deliberately no MCP tool to approve jobs or change the policy.

Public data used (all linked)

Where compute is (Map tab + world_compute tool)

ATLAS Global Data Center Map: 6,131 datacenters with coordinates, operators and cities
Epoch AI Frontier Data Centers (CC BY 4.0): frontier AI sites with power (MW), H100-equivalents and owners, geocoded with OpenStreetMap Nominatim
TeleGeography Submarine Cable Map (GeoJSON API): 733 undersea cables
CelesTrak orbital elements: live orbits of Starcloud-1 (an H100 in orbit) and the ISS (HPE Spaceborne Computer-2), propagated with SGP4 for sunlight windows and ground-station passes
NASA/NORAD Natural Earth land via world-atlas TopoJSON for the basemap
Underwater datacenters from public reporting: Microsoft Project Natick, Hainan (HiCloud) and Shanghai Lingang

What compute costs right now (quotes + compute_map)

Vast.ai public GPU pricing feed (JSON, hourly): live price and availability for 15 GPU types (~1,600 GPUs listed today)
OpenRouter models API: which LLMs are free to call right now
Modal pricing: per-second GPU prices (T4 → B200)
NVIDIA datasheets: TFLOPS and VRAM for the estimator
Kaggle and Colab free-tier docs

Training + research

Hugging Face Hub: public datasets and models (e.g. guanaco-llama2-1k, SmolLM2, Qwen2.5)
Market research: SemiAnalysis ClusterMAX, arXiv 2410.23261 (85% of academic NLP researchers have $0 cloud budget)
Photo: CERN Computer Centre, Simon Waldherr, CC BY-SA 4.0

Responsible data use

Vast's feed allows display with attribution but not redistribution, so we keep only the latest snapshot, always attribute it, and never archive or redistribute it
Every launch states what data leaves the device before it runs, and logs it
Local-first: when your machine can do it, it's $0 and the data never leaves
Dashboard binds to localhost only and rejects cross-origin requests

Challenges

Small models can't saturate a GPU, so we calibrated the estimator's utilization curve on a real M2 run (~12% MFU at 135M params)
A stalled model download slipped past the in-loop time cap, so we added a watchdog plus an external kill
Modal needs a payment method before GPU use. connect_provider detects this in 3 seconds without spending anything

Accomplishments

An agent chose a real NVIDIA H100 on Modal for a benchmark: 767 TFLOPS for $0.0034, under a $0.50 hard cap enforced as Modal's own timeout
Orbital compute marketplace: asked to "run this on satellite compute under $1," the agent browsed live offers, booked Starcloud-1's sunlit H100 window, got the real next downlink pass (AWS Ground Station Oregon, 63° elevation) and ran the job on an H100 under the satellite's timeline. Orbits, sunlight and passes are computed live with SGP4; operator listings and prices are mock, and the agent said so
A real agent, asked to "build a search index of my notes without hogging my laptop," checked the compute map, sent the job to a shared node and got 56 passages embedded on its GPU
A real agent (Claude Code) used it correctly on the first try: it quoted, picked the free local GPU, launched with a $1 cap and reported status
A real LoRA fine-tune on the M2 GPU: loss 2.75 → 2.23, $0.00, settled in the audit log
A 30-second cap stopped a job at 24 seconds, as designed