BASIS

The inference layer for the agent economy

The decentralized inference market for agents.

Workers publish models, prices, and capacity. Basis verifies offers, routes requests, records receipts, and settles jobs through $BASIS on Base.

Agents need inference. Workers set the market. $BASIS settles the job.

Try inference Explore worker market Run a worker

Inference LiveOpenAI-compatible · settled on Base

Worker offers · live market

$0.001 / credit · USDC-pegged

Self-reported offers — verification opening.

basis-m4max-01

Apple M4 Max (Metal, unified memory) · 36GB

Offer expired

basis-default

ollama

Prompt / 1M

88 cr

$0.0880

≈ 0.088 $BASIS

Output / 1M

352 cr

$0.3523

≈ 0.3523 $BASIS

ctx: 32,768
max out: 2,048
concurrency: 1

Receipts lock the jobWorker 90% / burn 10%Full market →

Network status

What is live right now, stated plainly.

The exact state of each path — inference, the worker market, payments, the on-chain fee route, and settlement. Read live from the same sources the API serves, and published at /api/launch-status.

Network data →

Inference API

live

OpenAI-compatible. Served now through a hosted upstream; the public demo is free and metered.

Orchestrator

live · hosted

The hosted orchestrator is up and authenticates worker dispatch. It selects an eligible worker when one is online.

Worker market

storage live

Signed worker model, price, and capacity offers. Offer storage is live and durable.

Worker offers

1 published

Live published offers right now. Run a worker to publish yours.

Payment routing

quote-only

The router quotes WETH, ETH, or USDC into $BASIS. Your wallet signs the swap — Basis never signs or custodies.

Fee router

configured

The on-chain spend sink that splits spent $BASIS 10% burn / 90% worker. Deployed and wired to the credit vault.

10% burn / 90% worker route

mainnet-proven

The on-chain 10% burn / 90% worker reward split has been proven by a controlled mainnet transaction — not a continuous live feed.

Paid inference

free demo

The public API does not require credits today — it is the free metered demo. Paid $BASIS credits come online behind their own gate.

Public worker routing

Requests route to a worker only when a real verified worker is online and eligible. Today the gateway serves through the hosted upstream.

Settlement

keeper-driven

Worker rewards batch deterministically. Settlement is operator and keeper driven, prepared off-chain first — not a continuous automatic service.

Today the public API serves a free, metered demo through a hosted upstream; it does not require $BASIS credits and does not route to contributor workers. Worker routing turns on when a real verified worker is online and eligible. The 10% burn / 90% worker reward route has been proven by a controlled mainnet transaction; it is not a continuous live feed. This is not yield and not an investment.

Try inference

Run a completion from the browser.

Sign in, pick a model, and send a prompt straight to the network. The same request travels the same path every job does — routed, served, and recorded to a receipt. Behind the scenes it is the OpenAI-compatible API any client can call.

Use the API instead →See what a job records →

Initializing console…

Worker-powered inference

An OpenAI-compatible inference network, settled on Base.

A model call enters the gateway and is served by compute on the network. Apps pay in $BASIS, workers earn $BASIS for the completed, verified jobs they serve, and every job is accounted to a verifiable receipt. The on-chain reward route is proven; routing public jobs to contributor workers turns on as verified workers come online.

Agents

Send model calls to an OpenAI-compatible endpoint.

Workers

Supply compute to serve those calls.

Base

Settles the accounting for every completed job.

Agents → Gateway → Workers

Compute on the network serves inference for agents and apps.

A request enters the gateway and is routed across a coordinated network of GPU workers. The contributor worker network is being activated.

Agents

Query

Gateway

Route

Workers

Serve

OpenAI-compatible API

Use the OpenAI SDK pattern with the Basis base URL.

Point any OpenAI client at Basis and call chat completions.

openai-compatible

base_url = https://basis.watch/api/v1

model = basis-default

client.chat.completions.create(…)

Pay in $BASIS

Credits are denominated in $BASIS.

ETH, WETH, or USDC can route into $BASIS at payment time.

Pay in

ETHWETHUSDC

$BASIS

via router

Credits

usage unit

The request path

One accountable pass, from model call to recorded receipt.

Every request travels the same path. An app or agent calls the API, the gateway routes it, compute serves the model, tokens stream back, and a receipt records the job.

Call the API01
Point an OpenAI client at the Basis base URL.
Gateway routes02
The request enters the gateway and is dispatched.
Compute serves03
A model is served and tokens stream back.
Receipt records04
Model, tokens, worker, and pricing are hashed.

Query → Route → Stream → Receipt → Reward → Settle

Query
Route
Stream
Receipt
Reward
Settle

01Query
02Route
03Stream
04Receipt
05Reward
06Settle

Workers earn $BASIS

Completed jobs earn. Failed jobs do not.

A worker serves a job, a receipt records it, and a completed, verified job pays a $BASIS reward to the worker’s reward address. A failed or rejected job creates no payable reward, and a worker needs a valid EVM reward address to earn. The contributor worker network is being activated; this is not yield and not an investment.

Run a worker →Worker guide →

GPU worker → Receipt → $BASIS reward

GPU worker

serves the job

Receipt

records the job

$BASIS reward

completed jobs

soon

completed → paysfailed → no rewardworker network activating

Receipts & accounting

Every job leaves a verifiable receipt.

A receipt records the accounting fields of a job — model, tokens, worker, pricing, and settlement — hashed over its immutable economic core. It never records prompt or completion text. Server token counts are authoritative; duplicate jobs and receipts are rejected.

View receipts →Receipt model →

Receiptverifiable

model: basis-default
tokens: prompt + output
worker: 0x8ba0e2…dc38
pricing: epoch · snapshot
settlement: Base batch
hash: 0xa03f17cc84aa…22272a

Accounting fields only. Receipts never record prompt or completion text.

Base settlement

Rewards settle through keeper batches on Base.

Worker rewards accumulate in the ledger. A keeper batches them into a deterministic batch and prepares an on-chain settlement that settles once — a batch settles a single time. The settlement contracts are deployed on Base; settlement runs operator and keeper driven, prepared off-chain first, not as a continuous automatic service.

Settlement →Settlement model →

Ledger → Keeper → Base

Ledger

worker rewards

Keeper

batch · prepare

Base

settles once

soon

on-chain settlement activating

$BASIS & Bankr

$BASIS is the unit of account. Bankr is the launch rail.

Apps and agents pay in $BASIS, workers earn $BASIS, and the two fee streams are kept apart. $BASIS is live on Base — it came to market through Bankr, which is the launch rail, not the inference backend. This is not yield and not an investment.

Pay

Apps and agents pay for inference in $BASIS.

Earn

Workers earn $BASIS for completed, verified jobs.

Fee rails

WETH-side and $BASIS-side fee streams stay on separate rails.

Launch rail

$BASIS came to market through Bankr on Base and is live.

WETH-side · $BASIS-side

WETH-side

ETH-denominated

separate

soon

$BASIS-side

token-denominated

separate

soon

The WETH side and the $BASIS side are never blended into one number.

$BASIS & the token loop →Treasury & fee streams →Bankr launch on Base →

Developer quickstart

Same client. Basis base URL.

Point any OpenAI client at Basis. Use the model basis-default, stream /v1/chat/completions, and the request flows through the same loop every job does.

Base URL: https://basis.watch/api/v1
Model: basis-default
Auth: Bearer sk-basis-…

Read the API docs →

Stream a completion

bash

curl -N https://basis.watch/api/v1/chat/completions \
  -H "Authorization: Bearer sk-basis-..." \
  -H "Content-Type: application/json" \
  -d '{"model":"basis-default","stream":true,
       "messages":[{"role":"user","content":"Summarize this for an agent."}]}'

Same client, one base URL

python

from openai import OpenAI

client = OpenAI(
    base_url="https://basis.watch/api/v1",
    api_key="sk-basis-...",
)
client.chat.completions.create(
    model="basis-default",
    messages=[{"role": "user", "content": "Hello from an agent."}],
)

Worker quickstart

Connect a GPU, serve jobs, earn $BASIS.

A worker registers, heartbeats, and serves inference. The orchestrator counts output tokens server-side — worker-reported counts are advisory. Completed, verified jobs earn $BASIS; failed jobs earn nothing. The contributor worker network is being activated.

Run a worker →Worker guide →

01
Connect wallet
A worker needs a valid EVM reward address to earn.
02
Register
Announce the worker to the network.
03
Heartbeat
Stay live so the orchestrator can route to you.
04
Serve
Run inference jobs the gateway dispatches.
05
Earn $BASIS
Completed, verified jobs earn. Failed jobs do not.

Build on Basis

Bring your client. Basis brings the network.

An OpenAI-compatible API, contributor GPUs that earn $BASIS, and a verifiable receipt for every job — settled on Base.

Try inference Run a worker Read docs