Hyperspace Pods

A pod is the team primitive of Hyperspace. Identity at <slug>.hyperspace.sh, (optional) P2P GPU pool, (optional) BYOK $ treasury, and (optional) Hyperspace Go credit pool — four layers, each independently optional, all under one slug. Slack-style visibility. One auth. One bill.

@varun_mathur · Apr 16, 2026

290K views 3K likes 3.7K bookmarks 391 reposts

Free when local. A team of five paying for cloud AI burns $500–2,000/month on API calls. The same team's existing machines can serve competitive open models for free — the hardware is already on their desks. When a query genuinely needs a frontier model, the pod falls back to cloud at wholesale rates from a shared treasury.

No middleman. Prompts travel from your IDE to your pod members' hardware and back. No server in between reading your data. Pod state is replicated across your own machines using Raft consensus.

Automatic sharding. Tell the pod which model you want. It figures out how to split it across whatever hardware is online. No configuring layer ranges or calculating VRAM budgets.

Real NAT traversal. Friend behind a home router with a dynamic IP? Works. No VPN, no Tailscale, no port forwarding.

A pod is a private cluster of 2-10 trusted devices that pool their compute, models, and credits. Create a pod, invite your devices or friends, and collectively run models that no single device could handle alone.

Local (default) — Raft consensus across member devices. Works fully offline. State in ~/.hyperspace/pod.json. No cloud dependency.

Cloud — Create with pod create <name> --cloud. Adds a web dashboard, Drive (shared filesystem + vector search), marketplace listing, and a persistent coordinator on Hyperspace infrastructure.

Each layer is independently optional. A solo developer runs layer 4 only. A community runs 1 + 4. A team running its own GPU cluster runs all four. The same pods row in Postgres carries metadata for every layer; members come from one membership list; billing flows through two parallel pool RPCs that don't conflict.

The gateway picks the cheapest path automatically: P2P first (free if a member has the model), BYOK next (your provider, your $), Hyperspace Go last (pool credits). Federation lets pods burst to peer pods via x402 micropayments when no member has the model.

Set per pod. Members see the same thing regardless — strangers see different things based on the visibility flag. Backwards-compat: pods that pre-date mig 047 had their visibility backfilled from older boolean flags.

Visibility is enforced at app/pod/[slug]/page.jsx server-side and at every pod-scoped API route. Toggle from the pod admin panel or via hyperspace pod-cloud visibility <mode>.

Pricing is per pod, not per user. Members are bundled. The Hyperspace Go pool stacks on top of layers 1–3 — you can run BYOK and Go together.

Each model has a class; class determines credits-per-request. Heavy frontier models cost more per call than the cheap classes — this is what makes pooling fair.

Pod admins set per-member sub-caps so one member can't drain the team pool. The hg_consume_pod RPC checks both the pool window and the member's individual cap atomically before each call.

Start from the CLI, link to the cloud later.

Admin creates the pod on the web, members join via link.

All commands support --json for machine-readable output.

Drives the cloud-side pod row at <slug>.hyperspace.sh — visibility, Hyperspace Go subscription, per-member credit caps. Different from coord commands, which drive Raft state on member machines.

Route requests to cloud providers when local inference is unavailable or a specific model is needed. Two modes: BYOK (member supplies their own API key) and Funded (pod treasury pays).

Control how much each member can spend on cloud inference from the treasury.

Every cloud inference call runs check_and_reserve_budget before dispatching to the provider. Over-budget requests return 429 Too Many Requests.

The gateway routes every inference request through a priority chain. The first tier that can serve the request wins.

Budget enforcement applies at every level. Even BYOK calls are logged and count toward usage analytics. Funded calls are blocked if the member exceeds their budget allocation.

Shared filesystem with automatic text extraction and vector search. Every file uploaded to Drive is indexed and searchable by any pod member.

An always-on agent daemon running on a cloud VM. The pod provisions and manages the lifecycle automatically — you choose the provider and model.

The VM auto-provisions the cheapest available instance matching your requirements. Uses BYOK credentials for the cloud provider.

Deploy lightweight services that run alongside your pod. Services are accessible from the pod dashboard and via your custom domain.

Services are deployed from the pod web dashboard or via the CLI. Each service gets a URL at <slug>.hyperspace.sh/apps/<name>.

Sync external data sources into Pod Drive. Connectors run on a schedule and automatically index new content for vector search.

Every pod gets a <slug>.hyperspace.sh subdomain auto-provisioned via Cloudflare Worker. You can also bring your own domain.

Reusable agent recipes. A template bundles a model configuration, system prompt, tools, and services into a shareable package.

Pods can form bilateral trust relationships with other pods. Federation extends your pod's capabilities without merging membership.

Alliances use Ed25519 federation envelopes — signed messages with a 5-minute TTL to prevent replay attacks. Trust is bilateral: both pod owners must approve. Duration is configurable (default: 30 days, renewable).

Every state change is an Ed25519-signed command replicated through Raft. No single member can forge transactions.

Every command is wrapped in a signed envelope before Raft replication:

Replay protection: unique nonce (24h retention) + timestamp drift check (5 min window vs cluster time). Domain separation: namespace-scoped signing prevents cross-topic replay of GossipSub messages.

Hyperspace provides a native MCP server for Claude Code. This lets Claude Code manage your pod, run inference, and use all 30+ tools without leaving the conversation.

Once registered, Claude Code can call tools like pod_status, pod_infer, models_pull, pod_shard_model, and pod_create_api_key directly.

You can create a Claude Code agent that uses your pod as its inference backend. This gives you a sub-agent powered by your own hardware.

If you add the agent to your Claude Code config, you can invoke it as a slash command:

The Vega pod is our reference deployment for testing three scenarios:

1. Cross-device sharding. Split Qwen3.6-27B BF16 (53.8GB) across H100 + Mac M3 Max using pipeline parallelism. The smart shard planner assigns layers proportional to each device's usable memory.

2. Benchmark sharded vs single-node. Compare latency and throughput when the model runs entirely on the H100 (Q8_0, fits in 80GB) versus sharded BF16 across two devices. Measure activation transfer overhead via libp2p.

3. Claude Code agent integration. Run a production Claude Code agent that routes coding queries through the Vega gateway. Qwen3.6-27B with thinking mode provides reasoning-heavy code generation at zero external API cost.

View pod status page →

Pods run any GGUF model from HuggingFace. Pull with quantization selection:

Thinking models (Qwen3.6): set max_tokens: 8000+ to allow room for internal reasoning. The gateway preserves reasoning_content in responses.

Full changelog: changelog.hyper.space