Get started

Deference is a network of volunteer GPUs serving open-weight language models. You can join it from either side: put a machine in, and earn credit for the tokens it generates; or spend credit on inference from any OpenAI- or Anthropic-compatible client, including Claude Code. Most people do both.

Read this first

A machine owner can read the prompts their machine serves. Machines are public by default. Do not send anything you would not paste into a stranger's terminal, or use a private machine of your own.
Your GPU serves strangers, and traffic leaves from your IP. Set an egress cap if you have a data allowance; the agent stops serving when it is reached.
Credits are not money. They are earned by serving, spent by consuming, cannot be transferred or cashed out, and expire after ninety days unspent.

The full text is at /terms; accepting it is part of creating an account.

Step 1 — Create an account

Create an account and accept the terms. The first account on a fresh deployment becomes the administrator. Every new account gets a welcome grant, and can claim the same amount once a day from the Tokens page, so you can try the network before contributing anything.

Step 2a — Contribute a machine

You need a computer with a GPU: an NVIDIA card (vLLM or llama.cpp), an Apple Silicon Mac (llama.cpp on Metal, or MTPLX on M4 and newer, which is about twice as fast on the same weights), or an AMD card with ROCm. The agent probes the hardware, picks the best catalogued model that fits, downloads and hash-verifies the weights, and serves them through an outbound tunnel. No port forwarding, and the inference server only ever listens on your loopback interface. What your card can run is on the Models page.

Go to Machines and create a join code. It is single-use and expires in a day; it is how the machine gets attributed to your account.
On the GPU machine, run the one-liner the join code shows. It installs the agent into /opt/deference (or ~/.deference without root), verifies the signed release before running any of it, and starts a service that keeps the agent running and rolls a bad update back on its own:
```
curl -fsSL https://<control-plane>/install.sh | sh -s -- --join-code jc-… --control-plane https://<control-plane>
```
Developer route: run the agent from a checkout
```
export DEFERENCE_AGENT_CONTROL_PLANE_URL=https://<control-plane>
export DEFERENCE_AGENT_CONFIG=$HOME/.deference/agent.toml
export DEFERENCE_AGENT_STATE_DIR=$HOME/.deference/var
export DEFERENCE_AGENT_MODEL_CACHE_DIR=$HOME/.deference/var/models
DEFERENCE_AGENT_JOIN_CODE=jc-… uv run deference-agent run
```
On an M4 or newer Mac, brew install youssofal/mtplx/mtplx (or the agent's mtplx extra) before starting, and the planner will pick the MTPLX pack of the same model over the GGUF. Powered by MTPLX.
Add --variant qwen3.5-0.8b-q4_k_m for a quick first run with a 500 MB download; without it the planner picks the largest model your hardware fits. uv run deference-agent plan --explain shows every candidate and why each was or was not chosen. The identity is written to the config file, so later runs need no join code.
Watch the machine on Machines: downloading, starting, then ready. The first download can take a while; a 27B model at Q8 is about 27 GB, and the machine's page shows how far along it is and at what rate. Once it is ready the network sends it an arithmetic canary probe, and traffic follows.
Decide who it serves. Public serves the whole network and earns credit from everyone. Private serves only you, which is the right setting for your own code and documents. Toggle it on the machine's page, along with an egress cap.

Step 2b — Use inference

Create a key on API keys. It is shown once. Each key has a requests-per-minute and a concurrent-streams limit you can lower yourself.

Point any OpenAI-compatible client at the network. Ask for a tier and the scheduler picks a machine, or name a catalog model id to require it:

export OPENAI_BASE_URL=https://<control-plane>/v1
export OPENAI_API_KEY=sk-def-…
# model: deference-tiny | deference-small | deference-medium | deference-large | <model id>

Or use Claude Code. Set all three model variables; Claude Code resolves its aliases client-side, and the haiku alias drives background work, so route it to a small tier:
```
export ANTHROPIC_BASE_URL=https://<control-plane>/anthropic
export ANTHROPIC_API_KEY=sk-def-…
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deference-tiny
export ANTHROPIC_DEFAULT_SONNET_MODEL=deference-medium
export ANTHROPIC_DEFAULT_OPUS_MODEL=deference-large
claude
```
Claude Code's system prompt and tool schemas are large, so the network only routes a claude-* model id to machines with at least 64k tokens of context. Open-weight tool calling is weaker than Claude's; expect the occasional malformed call.
Try it in Chat, and watch the spend and the host's matching earn appear on Tokens.

How credit works

Every request places a hold for the worst case, then settles for what was actually generated, on every path including a cancelled stream. The consumer's spend equals the host's earn plus a network fee; the fee is what keeps the daily grants from being pure inflation. Prompt tokens are counted by the network with the model's own tokenizer; completion tokens are reported by the host and bounded against what the network relayed, so a host cannot invent an order of magnitude. Prices per tier are on the Models page.

When something is off

You see	It means
529 overloaded_error with retry-after	Nothing is serving that model right now (a machine has to join), or every machine that does is at capacity (a slot frees in seconds). Clients retry on their own.
429 rate_limit_error	Your key's per-minute or concurrent-stream limit; see API keys.
402 insufficient_credits	Claim the daily grant on Tokens, or contribute a machine.
A machine stuck in downloading	Large weights over a home link; the agent resumes across stalls. Its detail page shows the last error.
A machine quarantined	It answered canary probes wrongly, or reported token counts outside the metering envelope. An administrator can restore it; the owner cannot undo it.

Anyone party to a request can report it by its request id, which appears in both parties' ledgers; the network keeps no prompts and no hashes of prompts, so the id is the whole record.