Compute is scarce and idle at the same time
Inference, far more than training, is becoming the dominant cost line for teams shipping models. Assistants, agents, code generation and document processing burn tokens around the clock. That capacity sits with a handful of cloud providers, which means high prices, quotas, waitlists for high-end cards, and terms that can change overnight.
The hardware to relieve it already exists. Millions of capable GPUs are inside gaming PCs, creator workstations and the racks of small hosts. A recent consumer card comfortably runs mid-sized open-weight models; cards with more VRAM handle much heavier models once quantized. These machines are busy a few hours a day. The rest of the time their capacity is simply wasted.
Vacuum is a market for those hours. Operators earn USDC for every token they generate. Builders get inference well below cloud prices. In between, audits, canary requests and posted collateral make cheating more expensive than honest work.
One request, end to end
An operator installs the client, registers their hardware, posts collateral and joins the network. Whenever the machine is free it receives requests, runs them locally and streams the result back. Inference happens off-chain, on someone’s own GPU.
What goes on-chain is everything needed to prove and to punish: the exact identity of authorized models, posted collateral, a cryptographic commitment to every execution, audit results, disputes and penalties. Running a language model on a blockchain is not realistic. Making its output accountable is.
In the first version each request is served entirely by one machine. Splitting a model across GPUs connected over the internet adds latency interactive inference cannot tolerate, so large models stay on nodes with enough local memory.
- 1RequestThe builder names a model. The maximum cost is reserved from their prepaid USDC balance.
- 2RouteThe router picks a compatible node on class, latency, availability and reputation.
- 3InferenceThe operator runs the model locally and streams the response back.
- 4ReceiptThe operator signs the model ID, prompt hash, response hash, token count and timestamp.
- 5CommitReceipts are aggregated per epoch into a Merkle tree whose root is published on Arc.
- 6ChallengeA sampled share of receipts goes to verifiers. Disputes open during this window.
- 7SettleThe window closes, earnings unlock, and the operator can claim them in USDC.
Why the settlement layer is Arc
An inference network generates an enormous volume of micro-transactions: thousands of requests, each worth a fraction of a cent. The settlement layer has to be fast, cheap and above all predictable.
Arc uses USDC as its gas token, so builders and operators think entirely in dollars with no exposure to a volatile asset and no conversions. Fees are stablecoin-denominated and predictable, which means on-chain settlement cost can be priced directly into the per-token rate without a safety margin. Sub-second deterministic finality means a confirmed payment is final and operators can accept work with no reorg risk. It is EVM-compatible, so contracts are Solidity and tooling and audits are standard. And CCTP lets builders fund accounts with USDC from other networks while operators withdraw wherever they want.
Arc is also built for programmable payments and agents. An autonomous agent holding a USDC wallet on Arc can buy its own compute on Vacuum, request by request, with no human and no credit card.
Live from rpc.mainnet.arc.io — currently unreachable from this page
Nodes are sorted by what they can hold
Hardware is grouped into classes, mainly by available VRAM, which determines the models a node can serve and the collateral it must post.
Spark
Entry and mid-range gaming cards
Small quantized models, embeddings, classification
Core
High-end consumer cards
Mid-sized models, chat, code generation
Forge
Workstations and pro cards
Heavier models, long contexts
Vault
Small data centres, multi-card servers
Large open-weight models, high throughput
An operator can never know which request is checked
Every model served on Vacuum is registered on-chain under an ID derived from the hash of its weights, its quantization format and the inference engine version. An operator commits to serving exactly that model. Quietly swapping a large model for a smaller, cheaper one is fraud, not a grey area.
Audits do not regenerate the response word for word — small numerical differences between GPUs would fail an honest node. The verifier runs the prompt and the submitted response through the declared model in a single pass and measures how likely that model was to produce this exact sequence. An honest response scores in line with the model. A fabricated one, or one from a different model, stands out. The check is fast, far cheaper than the original generation, and robust to hardware variation.
The audit rate is adaptive: high for a new operator, falling as the node builds a clean record, and never reaching zero. Canary requests, indistinguishable from real traffic and with known expected output, run continuously alongside.
A failed audit opens an on-chain dispute. The operator answers with their own evidence and a second, independent set of verifiers settles it. Confirmed fraud slashes collateral, voids unclaimed earnings, refunds affected builders and removes the node. A verifier who opens an unfounded dispute loses part of their own collateral.
What a request is worth, and to whom
- 80%
- Operators
- Payment for the compute provided
- 5%
- Verification
- Verifier rewards and the cost of canary requests
- 15%
- Protocol
- Half to treasury, half to open-market $VACUUM buybacks
Inference is billed in USDC per million tokens, priced separately for input and output, per model. Builders top up a prepaid balance and each request is debited at its actual cost. Prices are reviewed as node supply and demand move, with one constant: stay structurally cheaper than the major clouds on equivalent open-weight models.
To receive traffic an operator posts USDC collateral, with a minimum set by node class — the more requests and the more expensive the models a node serves, the higher its collateral. Earnings stay locked through the epoch’s challenge window, then become freely claimable. Collateral can only be withdrawn after an exit period, so no recent fraud can outrun a slash.
| Model | Quant | Class | In | Out |
|---|---|---|---|---|
| llama-3.3-70b-instruct | Q4_K_M | Forge | $0.18 | $0.55 |
| qwen2.5-32b-instruct | Q5_K_M | Core | $0.09 | $0.28 |
| mistral-small-24b | Q5_K_M | Core | $0.06 | $0.19 |
| gemma-3-12b-it | Q4_K_M | Spark | $0.03 | $0.08 |
| bge-m3 (embeddings) | F16 | Spark | $0.012 | — |
USDC per million tokens. Target pricing for Phase 1, not a live catalogue — the network is not yet accepting production traffic.
USDC is the currency. $VACUUM is the coordination
Routing priority
Operators who stake $VACUUM on top of their USDC collateral get a priority boost in node selection, at equal reputation.
Fee discounts
Builders who stake receive tiered discounts on their per-token price.
Buybacks
Half of the protocol share buys $VACUUM on the open market. Volume is tied to real network usage, not to emissions.
Governance
Over time, stakers vote on protocol parameters: models in the registry, audit rates, collateral amounts, revenue split.
Inference is paid in USDC and operators are paid in USDC. Token emission, distribution and vesting parameters will be published separately ahead of launch.
Change the base URL. Nothing else changes.
For builders
Vacuum speaks the request format you already use. In most cases migrating means changing the base URL and the API key. Streaming, system messages and the usual generation parameters all work.
The catalogue covers the main open-weight families in several sizes and quantization levels. Each model shows its registry ID, price, observed average latency and how many nodes are serving it.
For autonomous agents there is a direct path from an Arc wallet: the agent signs its own requests and settles in USDC, with no account and no human-managed key.
import OpenAI from "openai";
// The only two lines that change when you migrate.
const client = new OpenAI({
baseURL: "https://api.vacuumfi.com/v1",
apiKey: process.env.VACUUM_KEY,
});
const stream = await client.chat.completions.create({
model: "llama-3.3-70b-instruct-q4",
messages: [{ role: "user", content: "Summarise this receipt." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}For the people with the GPUs
Becoming an operator takes three things: a machine with a compatible GPU, a stable connection, and a wallet on Arc.
The client detects your hardware, downloads and verifies the models suited to your class, then runs in the background. You set your availability windows and can pause the node at any time — to play a game, for instance. The GPU is freed within seconds and the router redirects traffic elsewhere.
A dashboard shows requests served, accrued and claimable earnings, reputation and audit results in real time. Reputation converts directly into revenue: a reliable node receives more traffic and fewer audits. An unstable one sees its traffic shrink long before any formal penalty. If a node fails mid-request the router fails over automatically, the operator is not paid for that request, and their uptime score reflects it.
What Vacuum cannot do yet
In the current protocol the operator executing your request can technically see the prompt and the response in plaintext. This is inherent to running inference on consumer hardware, and it is not something a marketing page should bury.
For that reason Vacuum is not intended, at this stage, for sensitive or regulated data.
Several measures reduce exposure. Requests carry no builder-identifying information. They are spread across many nodes. The operator client retains nothing after execution.
A service tier restricted to nodes running inference inside confidential execution environments is on the roadmap, for workloads that require it.
What an attacker would try
| Threat | What it looks like | What stops it |
|---|---|---|
| Model substitution | Serving a smaller model than the one declared | Registry ID bound to the weights hash, likelihood audits, canaries |
| Fabricated responses | Returning generic or truncated text | Canaries, sampled audits, slashing |
| Overbilling | Claiming more tokens than were generated | Token count is recomputable from the response committed in the receipt |
| Operator–verifier collusion | A verifier covers for an operator | Random audit assignment, second independent verifier round |
| Sybil nodes | Spinning up many fake nodes | Collateral per node, reputation earned over time |
| Abusive accusations | A verifier targets honest nodes | Verifier collateral, slashing for unfounded disputes |
| Downtime | A node drops mid-request | Automatic failover, no payment, reputation impact |
Vacuum’s contracts will undergo independent security audits before any production deployment, and the reports will be published.
Where this goes
- Phase 1
Suction
Contracts live on Arc. Operator client for Core and Forge. Initial model catalogue, builder API, team-operated router, audits and canaries active.
- Phase 2
Expansion
Spark and Vault open. Broader catalogue. Native agent access from Arc wallets. $VACUUM launch, staking and buybacks.
- Phase 3
Dispersion
The verifier role opens to everyone. The router decentralizes progressively. On-chain governance is activated.
- Phase 4
Confidentiality
A confidential service tier for workloads that need it, and new workloads beyond text: image, audio, large-scale embeddings.