The decentralized inference market

What the market is

Any GPU can register a worker, sign a price manifest, and ask to serve OpenAI-compatible jobs for $BASIS rewards. The market is the set of current worker offers, each with the models it serves, the price it asks, and a read-time verification state. Basis does not set a single price for a worker model — a worker sets its own ask, and the network bounds that ask with rails and surfaces it with an honest verification label.

When no worker has published, the market is honestly empty: the API returns an empty list plus the network default price (the fallback a gateway-served job is metered at), never a fabricated worker.

The signed offer manifest

A worker broadcasts a manifest of the models it serves, its ask prices, and capacity, signed with its reward wallet. Signing with the reward wallet binds the offer to the address that will be paid — without the worker ever sending its private key. The price fields are integer raw micro-credits per 1M tokens (decimal strings, never JS numbers): one whole credit is 1,000,000 raw micro-credits, so 58 whole credits / 1M is 58000000.

{
  "manifest_version": 1,
  "worker_id": "worker-example",
  "reward_wallet": "0xYourEvmRewardAddress",
  "hardware": { "gpu_model": "RTX 4090", "vram_gb": 24 },
  "models": [
    {
      "model_id": "llama-3.1-8b",
      "runtime": "ollama",
      "prompt_credits_per_1m": "58000000",
      "output_credits_per_1m": "115000000",
      "min_job_credits": "50000000",
      "max_context_tokens": 8192,
      "max_output_tokens": 2048,
      "concurrency": 4
    }
  ],
  "valid_until": "2026-06-26T12:00:00Z",
  "nonce": "a-unique-nonce",
  "signature": "0x…"   // EIP-191 personal_sign by reward_wallet over the
                       //   canonical (sorted-key) JSON with "signature" removed
}

Verification states

Every offer reads as one of five states. Three are stored (self_reported / verified / rejected); two are overlaid at read time against the clock and the worker's heartbeat — so a stored verified offer reads stale the moment the worker goes offline, or expired once valid_until passes. A canary that ages out drops a verified offer back to self_reported — verification is a freshness window, not a permanent badge.

Ask-price rails

Workers set their own prices, but Basis bounds them so an ask can't be absurd: a floor (a worker can't dump below physical GPU cost, which signals a scam or a peak-batch claim that will fail under real load) and a ceiling (the network won't route an extreme overcharge). The defaults are research-anchored to real 2026 market prices and are env-overridable. An ask below a floor or above the max is rejected; an ask in the warn band is routable but flagged high.

Floors are output-anchored because decode dominates GPU cost; the prompt floor is roughly half the output floor, matching the market input/output ratio. The full derivation, sources, and GPU-hour floor math are in docs/research/worker-market-pricing.md.

USDC-pegged credits vs dynamic $BASIS

Price in Basis has two layers, and keeping them separate is the honesty win. The compute price is stable: a worker's ask and the model price table are denominated in USDC-pegged credits (1 credit = $0.001), so a model's credit price does not lurch with token volatility. Only the credits → $BASIS settlement is dynamic: at quote time the credit total converts to $BASIS at the active pricing epoch's rate, the conversion freezes into a hashed snapshot, and the receipt records both the credit cost and the locked $BASIS amount.

The credit→$BASIS quote is short-lived (a 120-second TTL) because $BASIS is volatile and a stale quote can't be honored. The credit price itself is not time-sensitive. The market API returns a worker's USD value per 1M (from the stable peg) and an indicative $BASIS amount at the active epoch rate — an estimate, never a promise. Until a price source is configured the live $BASIS conversion reports null and is never fabricated. Full pricing model: Credits.

Default network prices

These are the defaults the network advertises so a model always has a price even with zero workers online. A worker may ask less (down to the floor) and undercut the default. Anchored to real 2026 market prices plus a thin network margin (peg: 1 credit = $0.001 → credits/1M ≈ $/1M × 1000).

The network default (the proxy tier, 460 / 1,840 credits/1M) is the price a gateway-served job is metered at when no worker offer applies. The full market survey and per-model anchors are in docs/research/worker-market-pricing.md.

Publish an offer

Register the worker first (POST /api/workers/register), then POST a signed manifest to /api/workers/prices. The manifest reward wallet must match the registered worker wallet, and when authentication is required it must also be a wallet linked to your account. Each publish is stored as an immutable offer at the next price version; a new price is a new version, never an edit, so a receipt that references an offer preserves the exact economics forever.

# Publish a signed price/model manifest. The worker must already be registered
# (POST /api/workers/register), and the manifest reward_wallet must match the
# registered worker wallet. Basis verifies the EIP-191 signature recovers the
# reward wallet, the prices sit within the ask-price rails, and the manifest is
# not expired, then stores an IMMUTABLE offer at the next priceVersion.
curl -X POST https://basis.watch/api/workers/prices \
  -H "Content-Type: application/json" \
  -d @manifest.json
# → { "ok": true, "offerId": "worker-example:v1", "priceVersion": 1,
#     "state": "self_reported", "flags": [],
#     "note": "Offer published as self_reported. A canary can mark it verified;
#              capability is not cryptographically proven." }

Read the market

The market is public and secret-free. The market endpoint returns each worker's current offer with its read-time state and per-model economics; the per-worker endpoint returns one worker's current offer plus its price-version history.

# The public market: each worker's CURRENT offer (latest price version) with the
# read-time verification state and per-model economics (USDC-pegged credit price,
# the stable USD value, and an indicative $BASIS amount at the active epoch rate).
# Honest empty state: no published offers → { "empty": true } + the network default.
curl -s https://basis.watch/api/workers/market

# One worker's offers (current + price-version history). 404 if it never published.
curl -s https://basis.watch/api/workers/worker-example/models

Routing policy

The market exposes two routing policies. The default is verified_only: only offers that passed a fresh canary route. allow_self_reported is a strict opt-in for callers who knowingly accept unproven capability (cheapest-price experimentation, a user's own private worker) and must be labelled as self-reported capability, never as verified. stale / expired / rejected offers never route under any policy.

Activation status

The market is opening, and the docs are honest about what is live versus gated. Read GET /api/launch-status and GET /api/workers/onboarding/status for runtime truth — never infer live state from this copy.