Current Compute

Batch inference network

AI inference on the world’s idle GPUs.

Current Compute is an OpenAI-shaped batch API in front of a governed, verified fleet of idle hardware — data-center spares, office servers after hours, gaming rigs overnight. For the AI work that can wait minutes instead of milliseconds, at a fraction of frontier cloud prices.

  • OpenAI-shaped API
  • Verified results
  • Hard budget stops
  • No token, no wallet

The production dispatch path — gateway, scheduler, fleet. Animation illustrative; the architecture is real.

The Operator

You push a batch. The network is our problem.

Distributed hardware is chaotic — machines appear, vanish, and lie. The Operator is the orchestration layer that absorbs that chaos so what you experience is a boring, predictable cloud API.

Zero-touch orchestration

Push a batch; the scheduler leases units to matching nodes, hedges stragglers, and reassembles your output. When a GPU vanishes mid-job, its lease expires and another node finishes the unit — recovery is the default path, not an incident.

Verified, reputation-weighted results

Nodes earn trust on golden-set checks before touching real work, then stay under spot checks with tolerance and log-probability verification. Drifting nodes are quarantined automatically. You get answers, not hope.

Governed by default

Every request passes a governance gateway: hard-stop budgets that return 402 instead of a surprise invoice, data-loss-prevention screening, and an HMAC-chained audit log. Agent binaries are Ed25519-signed with downgrade protection.

Straight answers

What we promise — and what we don't.

Decentralized compute has an overclaiming problem. We'd rather be the honest version.

Batch, not real-time. We commit to completion windows — minutes to hours — never millisecond latency. Real-time serving stays on your primary cloud; the overnight lane comes here.

Open-weights models. Llama-class models whose outputs we can independently verify. We don't pretend to run proprietary frontier models on gaming rigs.

Non-sensitive data only. The gateway's DLP screen enforces it. Regulated or confidential workloads don't belong on third-party idle hardware, so we refuse them rather than promise magic.

An SLO, not nines. If the fleet can't meet your window, overflow escalates to frontier APIs so your batch completes either way. We quote a completion window, not uptime theater.

For developers

Ship a batch in one request.

No cluster to size, no nodes to babysit, no new mental model. If you can call an API, you can drain a million prompts overnight.

POST /v1/batches
curl https://api.currentcompute.com/v1/batches \
  -H "Authorization: Bearer $CC_API_KEY" \
  -d '{
    "model_id": "llama-3.1-8b-instruct",
    "prompts": [
      "Classify sentiment: the deploy finally went green",
      "Extract the company name: Acme Corp raised a Series B…"
    ]
  }'
# HTTP/2 201
{ "id": "9f2c…", "status": "accepted", "total_units": 2 }
  • Poll or fetch when done. GET /v1/batches/{id} for status, /output for results once your window closes.

  • Budgets with teeth. Set a hard cap and the API returns 402 at the line — overruns are structurally impossible.

  • Keys you control. Scoped API keys, shown once, revocable instantly from the console.

  • OpenAI-compatible gateway. Or point an existing OpenAI SDK at our TokenGuard gateway and route by model name — one line changed.

Pricing

Idle silicon has a different price tag.

The hardware already exists, is already powered, and was going to sit dark all night. That's the entire cost advantage — no financial engineering required.

Frontier hosted model
$15,000/mo
Current Compute fleet
$300/mo
You keep
$14,700/mo

Illustrative rates — $0.20 versus $10.00 per 1M output tokens, comparing an 8B-class open-weights model on the fleet against a frontier hosted model. Not a quote: your price depends on model, volume, and completion window. The honest caveat: an 8B model is not a frontier model — this trade is for the large share of work where it’s good enough.

Engineering proof

Proven in production, not in a deck.

Three claims every distributed-compute company makes — and our production logs from July 2026 backing each one.

Exactly-once under concurrency

A 30-unit batch drained by 3 nodes concurrently: exactly 30 completions recorded, zero double-work — the lease protocol holds under contention.

Failure recovery, unattended

A node vanished mid-batch holding a lease. The sweeper reclaimed it and another node finished the unit: 6/6 completed, zero loss, zero human intervention.

Governed end-to-end

Live traffic flows through the TokenGuard gateway — budget enforcement, DLP screening, and an HMAC audit chain that verifies. When a burst tripped the rate limiter, the key was suspended automatically. That’s the governance working.

Supply side

Own hardware that sleeps at night?

The network buys what you already paid for: the idle hours.

Companies & data centers

Office workstations and servers idle 60–70% of the week. A signed, inference-only agent turns those hours into revenue — and steps aside the moment the machine is needed.

How it works

Gamers & individuals

Your GPU earns while you sleep and yields the instant you touch the mouse. The provider console is live today — claim a node in minutes.

Open the provider console

Early access

Put the idle half of the internet to work.

Tell us what you'd run — or what you'd plug in. A human reads every submission.

What do you want to do?

Stored once, read by a human, never resold. See our privacy policy.