Open beta · self-hosted · your hardware

Lend a GPU, borrow a model

Lend your GPU when it is idle. Use the pool's models when you need one. Together the pool runs models no single machine in it could hold.

Offer my GPU Use the pool Log in
One commandto add your machine
Nothing to openno ports, no VPN
Yours to stopleave whenever you like

Where the pool stands today

Live from this community's own leader, not a marketing slide. Numbers are withheld while the pool is small - at that size they would describe one member's computer rather than a community.

··· machines online
··· GB of GPU memory
··· models to chat with
··· GPU-hours contributed

Two ways in, one pool

Some members bring a machine. Some just want a model that answers them. The pool is where those two meet: idle GPUs become capacity, and capacity becomes answers. Paying members back for what their machine contributed is the next thing we are building - today the trade is in kind, and the pool is free to use while it is in beta.

YOU HAVE A GPU 1 Run one command 2 Your machine joins 3 It helps while idle THE POOL One model, split across machines 3090 A4000 4070 YOU NEED INFERENCE 1 Join the same pool 2 Pick a model 3 Chat, or call the API capacity answers NEXT credit for what your machine contributed

You have a GPU

  1. Run one command
  2. Your machine joins
  3. It helps while idle

capacity in

The pool

One model, split across members' machines

answers out

You need inference

  1. Join the same pool
  2. Pick a model
  3. Chat, or call the API

NEXT credit for what your machine contributed

What runs on your machine

A fair question before you install anything. Three things are worth knowing, and none of them need a diagram to follow.

  1. The coordinator does not hold the model. One small always-on machine keeps track of who is in the pool and who is holding what. It needs no graphics card and never sees a copy of the model.
  2. Your machine holds one part, not the whole thing - and only while it is in the pool. Leave, and it stops.
  3. A question travels through the parts in order and comes back as an answer. Your machine does its share of that work and passes the result to the next one.
The coordinator no graphics card needed keeps track of who holds what Alice RTX 3090 holds part 1 Bob A4000 holds part 2 Carol RTX 4070 holds part 3 your question the answer dotted: coordination · solid: your question travelling through the parts
The coordinator no graphics card - it only keeps track of who holds what
Alice · RTX 3090 holds part 1
Bob · A4000 holds part 2
Carol · RTX 4070 holds part 3

Your question enters at part 1 and leaves part 3 as an answer.

Models too big for your card

The pool splits a model across its machines, giving each one a share sized to the memory it actually has. Nobody needs the card that could run it alone.

Your machine stays behind your router

It reaches out to the pool, so nothing has to reach in. No port forwarding, no VPN, nothing exposed to the internet.

Runs on home internet

Machines pass compressed intermediate results, not whole models, so a pool works over ordinary connections instead of a datacentre network.

Joining takes one command

Paste one line into a terminal. Your machine installs what it needs, joins the pool, and shows up live for the other members.

Bring the open models you already use

Qwen, Llama, GPT-2 and the rest of the open catalogue. Run them as they are, or train them further on the pool's own data.

Chat with it, or call the API

Anything the pool serves is available in the browser and through an OpenAI-compatible endpoint, so your existing tools just work.

Does contributing pay?

Not yet, and we would rather say so than imply otherwise. Here is the order we are building it in, and where it currently stands.

  1. liveSee what you contributed. Every machine's GPU-hours, tokens served and requests answered are recorded against the member who added it, visible on your profile.
  2. nextCredits. Contributing earns credits and using the pool spends them, inside one community. No cash, and no promises about a rate until the accounting above has run long enough to set one honestly.
  3. laterA published rate, so the trade is legible: what an hour of a given card earns, what a thousand tokens costs.
  4. laterPayouts in real money. That is company plumbing rather than a feature - who the merchant of record is, VAT, and how contributions are reported - so it lands last and only once it is right.

Before you install anything

The questions we would ask, grouped by what they are actually about. Answers describe what the software does today - if something is not implemented, it says so rather than sounding reassuring.

On your machine

What exactly gets installed?
One directory: ~/.silent-swarm holds the source, its own Python environment, a log file and a small config file. Nothing is installed system-wide and no service is registered.
Does it need root, or change my firewall?
Not by default. It runs as your own user and touches nothing outside that directory. Firewall rules are only added if you explicitly pass --allow-from when joining, in which case it opens the two pipeline ports to the addresses you named, writes down what it added, and removes exactly those rules when you purge.
Is it sandboxed?
No, and we will not pretend otherwise. It is an ordinary process running as you, with your permissions - not a container or a virtual machine. Run it on a machine where that is acceptable, and read the source if you want to know exactly what it does.

On the network

What does it open on the network?
It connects out to the pool, so nothing needs to reach in. While it is serving a model it also listens on two local ports so the neighbouring machines in the pipeline can hand it work; you can pin those to one network interface, such as a VPN, using the SWARM_ZMQ_BIND_HOST setting.
Who sees the prompts I send?
The machines in your pool that hold the model you picked. A pool is the boundary: a pool's model is only ever served on that pool's own machines. The coordinator routes the request and records timings, not the text of your prompt or the answer.
Can other members see my machine?
Members of your pool can see whether it is online and how busy it is - that is how a pool notices a machine in trouble. Nobody outside your pool sees it at all.

On your terms

Can I stop, and get my machine back?
Any time. Stop the process and it stops taking work; purge it and the directory is gone, along with any firewall rules it added. If you own the pool you can also park a machine on standby, so it stays a member without being given work.
Is the source public?
Yes - on GitHub, under a licence that is free for noncommercial use. The installer is fetched over HTTPS and checks the source archive against a published checksum before it runs anything.

Want the detail rather than the summary? The operations docs list every file the installer writes, every flag it takes, and how to remove it.

Under the hood

the mechanism, for the reader who wants it

The model is split into pipeline stages, stages stream activations to each other (direct peer-to-peer where the network allows, through the leader's relay where it does not), and a learned bottleneck at every stage boundary is what makes this affordable over ordinary connections. The docs go further.

  • Pipeline-parallel training and inference across mismatched GPUs, placed by free VRAM.
  • Learned bottleneck compression at each stage boundary, which is what makes a WAN pipeline economical.
  • Any HuggingFace causal LM - GPT-2, Qwen and Llama-family - from full fine-tuning down to a frozen backbone with a trained bottleneck.
  • Mesh P2P by default, with the leader's HTTP relay as the fallback for nodes behind NAT.
  • OpenAI-compatible API at /v1/chat/completions alongside the browser chat.
Joining a node looks like this:
curl -fsSL https://your-leader/api/v1/bootstrap/fellow.sh | bash
Leader - control plane mesh P2P by default · relay fallback behind NAT Stage 1 RTX 3090 · 24 GB Stage 2 A4000 · 16 GB Stage 3 2× 3060 · 12 GB Serve chat · API learned bottleneck learned bottleneck Your machines - mismatched GPUs, any VRAM, behind firewalls

SilentSwarm is in open beta

This is a soft launch: the core works - pipeline-split training, the mesh, the chat - but expect rough edges while we stabilize. Registration is a beta waitlist too: new accounts are reviewed and approved by an administrator before they can log in. Prefer to just stay in the loop? Leave your email and we'll keep you posted as the beta opens up (source release included).