Quotum Q markThe bell rings every day at 20:00 UTC.Take a seat

How a seat works

A hundred seats of private inference on Robinhood Chain, each a Venice key with a daily cap paid by the coin's trading tax.

Updated . What changed

For AI agents: llms.txt

Connect your agent§

One prompt in your coding agent wires your seat key. No seat? Take one at quotum.org/seat; Pay as you go is paused.

Paste into your coding agent

Connect this project to my quotum seat.

  1. Read https://quotum.org/llms.txt and https://quotum.org/AGENTS.md.
  2. Set this project's client base URL to https://api.venice.ai/api/v1. Keep your own agent backend.
  3. Read the key from QUOTUM_SEAT_KEY. Never print or commit it. No key yet: open quotum.org/seat, Other apps.
  4. Pick a private model from quotum.org/models.
  5. Send one small test call. Open See the call land on Your seat to inspect its cost and observation time.

Never ask for my seed or private key, sign for me, or move tokens.

Or install in Hermes Agent

hermes plugins install qvotvm/hermes-quotum --enable
  1. QUOTUM_SEAT_KEY from Your seat, Other apps: a seat key or the seat's Hermes Agent key.
  2. hermes usage after one small test call: cap, spend, what is left, the bell.

Listed on Hermes Agent Marketplace official catalog

What the key gets you

$0.24cap per seat, this session
134text models on Venice, private and anonymized
1.81Btokens the seats used in the last 30 days, at least

Saved figures. Every model and its price

It will

  • Set one env var and a base URL
  • Use a private model
  • Send one small test call

It will not

  • See your wallet or seed
  • Sign or move tokens
  • Swap its own model backend

Make a model call§

Use a seat key. Pay as you go project keys are paused.

Seat key

Copy your key from Your seat, or take a seat. Calls spend the daily seat allowance directly at Venice. Set base_url to https://api.venice.ai/api/v1.

Set the environment variable, then run this cURL request. It prints the provider's JSON reply.

curl
export QUOTUM_SEAT_KEY="your seat key"
curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $QUOTUM_SEAT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"deepseek-v4-pro","messages":[{"role":"user","content":"hello"}],"max_tokens":256}'

Expect a greeting. The wording varies. cURL returns it in choices[0].message.content; Python prints it. The provider meters the call against the daily seat allowance, not a Pay as you go project balance. Find the seat record.

What you'll see

A real reply to the cURL call above, recorded 10 Nov 2026 at 09:11 UTC. Trimmed, id shortened.
{
  "id": "chatcmpl-RP6E…",
  "model": "deepseek-v4-pro",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "Hello! How can I assist you today?",
      "reasoning_content": "We are instructed to respond…"
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 1681,
    "completion_tokens": 85,
    "completion_tokens_details": {
      "reasoning_tokens": 74 }
  },
  "cost": { "usd": 0.0030542 },
  "venice_parameters": { … }
}
  1. The reply. choices[0].message.content; Python prints it.
  2. The model's reasoning, apart from the reply. Here 74 of the 85 completion tokens.
  3. 1,681 prompt tokens for one word. Venice adds its own system prompt unless "venice_parameters": {"include_venice_system_prompt": false} is set. In our recorded call with it set, the same prompt took 5.
  4. What the call cost, against the seat's cap: $0.0031. Without the Venice system prompt: $0.00013.

Pay as you go project key

Pay as you go: the pilot ran from 29 October to 12 November 2026. Funding is paused while we review it; nothing is charged. Its base_url is https://quotum.org/api/payg/v1. Calls spend the prepaid project balance, within the key budget.

Set the environment variable, then run this cURL request. It prints the reply and billing JSON.

curl
export QUOTUM_PAYG_KEY="your project key"
curl https://quotum.org/api/payg/v1/chat/completions \
  -H "Authorization: Bearer $QUOTUM_PAYG_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"hello"}],"max_tokens":256}'

Expect a greeting, then a record ID and the actual dollar charge. Wording and cost vary. cURL returns choices[0].message.content and quotum_billing; Python prints them. This is expected output, not a recorded paid run.

Send a unique Idempotency-Key per logical request. Reuse it only to retry that request. A duplicate returns its record and duplicate_response, without output replay or a second inference. Python disables SDK retries with max_retries=0. Read the Pay as you go limits and error behavior.

Check a record

For Pay as you go, find quotum_billing.id in the response. Read https://quotum.org/api/payg/v1/receipts/<id> with the same project key as a bearer token. charge is in billionths of a dollar, so divide by 1e9. The same key reads the project's whole history, pages of 50 over up to 92 days, at https://quotum.org/api/payg/v1/receipts?from=<ms>&to=<ms>, and the same rows as a file at https://quotum.org/api/payg/v1/receipts/export?format=csv&from=<ms>&to=<ms>; on /payg the cabinet shows them under History and saves the CSV with Export. Project balance and key budget are separate from the seat session cap.

For a seat, open Your seat and choose Records, or read https://quotum.org/api/receipts?session=N for the session's provider-reported spend per seat. Direct Venice calls count toward that spend but are absent from the console call totals at /api/receipts/calls. Verify the record hash against the chain event.

The seat§

One wallet, 2,500,000 QUOTUM staked, one key. A hundred seats, a queue after them.

Stake per seat2.5MQUOTUM, fixed at deploy
Seats taken12 / 10088 places open
Queue0wallets waiting
Cap per key now$0.24session 57

SavedSaved figures, the live read replaces them

Your seat

Paste a wallet address or a seat number. The page reads the public keeper state and looks it up in your browser: the address is not sent anywhere and nothing is saved.

  1. Stake2,500,000 QUOTUM in the staking contract
  2. Seatone of a hundred, one key
  3. Sessionbell to bell, 24 hours
  4. Capthe smallest of three numbers
  5. Bell20:00 UTC, unspent buys and burns

Stake

Any amount, any time. At 2,500,000 QUOTUM you take the first free seat, or the tail of the queue when all hundred are taken.

Your walletSeatTaken SeatQueued

Leave

Unstake any time, mid-session too. Under 2,500,000 the seat frees, its key is deleted and the head of the queue moves in. You get the stake back, nothing else. Leave the seat on the seat page does it in one transaction, simulated first.

Your walletSeatFreed

Idle

Two sessions in a row at $0 while someone waits: you move to the tail of the queue and the next wallet is seated. The stake is not touched.

KeeperIdle

Connect a wallet

Any browser wallet, Rabby or MetaMask for example. Connect in the header shares your address and signs nothing; a wallet that holds a seat shows its number. On a phone, open quotum.org in the wallet app's own browser.

The coin lives on Robinhood Chain, chain id 4663: taking a seat asks the wallet to switch to it, and to add it first if needed. A signature comes only when you sign in to a seat, and it costs nothing and sends nothing.

Take a seat quotes ETH for the QUOTUM you need, routes ETH through NVDA to QUOTUM, returns unused ETH and stakes. Already holding enough QUOTUM: approve the staking contract, then stake.

The session§

One session runs from one 20:00 UTC bell to the next, every day, weekends and holidays included.

The open session ends at the next 20:00 UTC bell.

Open

Right after a bell the sink sets the cap for every seat from what the chain shows. It holds until the next bell.

SinkOpen

Use

The key works across bells while it has allowance. Every call is metered against the cap; when the cap is spent the key answers 402 until the next open.

Keeperthe meter

Bell

At 20:00 UTC each seat's spend is reported on chain. What was spent is paid to the provider; what was not can buy QUOTUM and burn it.

Keeper, sinkReported Bell

The first session, on launch day, ran from the launch to that evening's bell, so the first burn was the same evening.

The cap§

The regular cap is the smallest of three numbers: $50, a seat's share of the last day's trading tax, and 0.25% of the supply in dollars. In a sponsored session the key gets the sponsor's amount on top.

  1. Ceiling$50a session, fixed in the sinkOpen(session, capUsd, …)
  2. Tax share60%of the last 24 hours of trading tax, divided by the seats live at the openOpen(…, tax24hUsd, liveSeats)
  3. Seat value0.25%of the supply at the last session's average price, from the PriceObserverthe observer
Cap formula
cap per seat = min(
  $50,
  60% of the last 24h of trading tax in usd / seats live at the open,
  0.25% of the supply in usd at the last session's average price
)

Where the money comes from

The cap is paid by the coin's trading tax on the $QUOTUM / NVDA pair on Pons, collected in NVDA. Every claim splits once, in the sink, fixed at deploy:

If no seat is taken at the open, the cap is worked out as if there were one. If the tax dies the cap prints $0 and the page says so. Dollars here are dollars of inference at the provider's prices, not a share price.

Rules at the edges

  • Keys never get more than the contract holds. A seat taken after the open gets the cap, or what is left of the collected tax if that is less.
  • The first session, on launch day, gave every key the smaller of the cap and one hundredth of the collected tax, so a seat taken late got the same as a seat taken early.
  • Displayed key caps are rounded down to a cent. A homepage figure more than five minutes old shows when it was read and its age.

The bell and the burn§

At 20:00 UTC every day the keeper writes each seat's spend on chain and rings the bell. What the seats spent pays the provider. What they did not spend buys $QUOTUM and burns it, when the sink holds the NVDA and the price guard allows.

The last 14 bellsspent, paid to the provider not spent, burned not spent, held in the sink
  1. 43
  2. 44
  3. 45
  4. 46
  5. 47
  6. 48
  7. 49
  8. 50
  9. 51
  10. 52
  11. 53
  12. 54
  13. 55
  14. 56

bells.json, one bar per bell on one scale; a bell far above the rest is cut and labelled. Hover or focus a bar for its numbers.

The bell, in order

  1. report()Keeper

    For every live seat, what it spent and did not spend, read from the provider's usage of that seat's key, with the hash of the seat's record row. The leftover is cap minus spend.

    EventReported

  2. bell()Keeper

    The sink adds up not spent = cap − spent over every live seat.

    EventBell

  3. Buy and burnSink, in the bell tx

    The NVDA behind that sum buys $QUOTUM on the pair in one trade and the token's own burn() destroys it. The supply drops by exactly the tokens in the event, with the dollars, the NVDA and the average price beside them.

    EventBurned

  4. Price guardSink

    No buy above the pair's time-weighted price plus 10% and the pair's fees. It buys only with NVDA the tax has already paid into the sink, after what is owed to the provider. No NVDA behind the leftover, a leftover under one dollar, or a refused buy: the NVDA stays for the next bell.

    EventDied with the reason

  5. forward()Keeper

    The spent part's NVDA goes to one published payment address, which pays the provider. Every payment is posted with its tx on the front page and on /usage.

    ReadPAY_TO() on the sink

trading tax1%, in nvda the sink40% ops, 60% seats spent capowed to the provider not spentcap − spent, each seat venicevia the payment address burned$QUOTUM, supply down claimforward()buy, burn()bell() at 20:00 UTC trading tax1%, in nvda the sink40% ops, 60% seats spent capowed tothe provider not spentcap − spent,each seat venicevia the paymentaddress burned$QUOTUM,supply down claimbell() at 20:00 UTC forward()buy, burn()
At the bell the session's issued cap splits in two. The spent part leaves as a payment. The unspent part buys QUOTUM and burns it when the price guard allows.
The bell 45 record on /bell: 17 seats, $1.96 daily cap, $4.69 inference spend, $28.66 unspent, no burn, recorded 9 Nov 2026 at 20:01:01 UTC
What a bell leaves behind: the bell 45 record on /bellScreen of quotum.org/bell, 10 Nov 2026

What the chain shows

  • Each seat's spend and record hash, as Reported
  • The bell, the buy and the burn, in one tx
  • The supply after every bell
  • Every forward to the payment address

What it does not

  • The spend itself: the provider's usage of the key as the keeper reads it, which the chain cannot check
  • The step from the payment address to the provider, which is custodial; every payment is posted with its tx

Day keys§

Off since 30 Oct 2026

Holder day keys are off since 30 October 2026. A seat's allowance is used by its own seat key.

The house's own day key, separately budgeted and cut from the ops seat, is a different thing: see The call for agents. The console's E2EE route needs a day key.

The key§

Each seat has one Venice key. It is issued once the seat is taken on chain, limited to the session's cap and deleted when the seat is freed.

Limit now$0.24session 57
Lifetime90 daysrenewed 7 days before
Web search~$0.01a question, in the console
Cap spentHTTP 402the key's answer until the next open

SavedSaved figures, the live read replaces them

  1. Issuedafter SeatTaken, for private and anonymized models
  2. Limitedto the session's cap, metered at Venice
  3. Renewedseven days before the 90-day limit
  4. Deletedwhen the seat is freed

One key per seat, bound to the seat's wallet. No key exists before the stake is confirmed on chain. Any OpenAI-compatible client works: set base_url to https://api.venice.ai/api/v1.

Python
# the key is a venice key: venice's own endpoint
from openai import OpenAI
client = OpenAI(
    base_url="https://api.venice.ai/api/v1",
    api_key="your seat key",
)
r = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "..."}],
)

A real reply to this call, field by field: what you'll see.

What the console logs

  • The wallet
  • The model
  • The cost of each reply

What it does not

  • The prompt
  • The reply
  • Media prompts and output

The console

On the seat page the seat wallet signs once and chats on the seat's own key. Standard console requests go through quotum with the key on our server, which stores no prompt or reply text. Chat history stays in this browser, keyed to the seat and wallet. The public /api/receipts/calls endpoint gives UTC-day totals by model only after the day ended at least 24 hours ago, with at least three distinct seats per bucket; smaller buckets fold into other, which is suppressed if still too small. It exposes requests, tokens and rounded USD, without per-request or seat records. External-app calls are not in this console aggregate. The meter is the keeper's own read of the key plus the exact cost of replies since, the same number the keeper reports at 20:00 UTC.

  • Search. An optional web search lists numbered sources and adds about $0.01 a question.
  • Images and video. Switch the composer to image or video to make media on the same key. Image prices come from Venice's model list; video accepts an image as input and is quoted before it joins Venice's queue; the console polls quotum for the finished video, then shows a download link. Each cost enters the meter when Venice accepts the request. Prompts and output are not saved on our box.
  • Replies. Copy, text copy and rerun on another model, with sources, elapsed time, tokens and cost. Thinking seconds show while the model reasons. A stream silent for 90 seconds closes with the text received. Switching wallets stops the stream and keeps the draft question; a failed send keeps the question too.
  • Long chats send the question, the last answer and the earlier turns that fit; the reply footer says how many older turns were left out.
  • Tasks. Schedule a daily brief on a topic at the hour you choose, or the 19:30 UTC spend note. Runs appear in the console and a linked Telegram chat. The built-in brief searches with the current date and lists sources, preferring Kimi K3, then Grok 4.7 and DeepSeek V4 Pro; it is separate from the downloadable DeepSeek morning-digest profile.
  • Record. The seat's Record tab shows seals, tier progress, how many wallets hold each seal, the checked root and a share card. Copy the wallet address there, save the card or copy it as an image with a link to the public record. Held secret seals show their name and icon; undiscovered ones stay locked.
  • /check reads Pons v2 launch facts at no charge, but needs a signed-in seat with at least $0.005 left; an optional interpretation spends the key at the displayed current price. Recent checks stay only in this browser.

The key in other apps

For Hermes Agent, OpenClaw, Goose, Open WebUI or plain curl, the seat page shows each config with the key masked. Sign with the seat wallet, press copy, and the filled config goes to your clipboard. After a signature, Apps can show or copy the raw key for 60 seconds, then wipes it from the tab; it is never written to browser storage, the URL or logs. After installing, send one prompt and open See the call land to compare the last observed spend with your request. Apps also shows the last spend seen; Records lists recent sessions.

Key lifetime

A key lives 90 days at the provider. Seven days before that the keeper makes the seat a new key with what is left of the session's allowance, carries over what the old key spent, and deletes the old key. The meter and the bell do not move. Copy the config again once the seat page says the key was renewed.

Framework quickstarts§

Any client that speaks the OpenAI API takes a seat key. Set the base URL and the key, and keep the two together.

Seat key
https://api.venice.ai/api/v1Calls Venice directly and spends the seat's daily allowance.
Pay as you go project key
https://quotum.org/api/payg/v1Paused. The pilot ran from 29 October to 12 November 2026. Funding is paused while we review it; nothing is charged. See Pay as you go.

OpenAI SDK

Pass the seat key as api_key and the seat-key endpoint as base_url. The quickstart has it in curl and Python.

Seat-key quickstart

Hermes Agent

The quotum provider plugin. hermes usage then shows the seat's cap, the spend, what is left and the bell.

Hermes Agent setup

OpenClaw

The seat page has an OpenClaw config with the key masked. Sign with the seat wallet and copy it filled.

The key in other apps

DeepSeek Harness

No harness-specific guide on this page. Set it up as an OpenAI-compatible client with the seat-key endpoint and the seat key.

Seat-key quickstart

LangChain

No LangChain-specific guide on this page. Use its OpenAI-compatible chat client with the seat-key endpoint and the seat key.

Seat-key quickstart

Goose, Open WebUI, curl

Each has a config on the seat page too, key masked until the seat wallet signs.

Your seat

E2EE§

Day keys off

Holder day keys for others are off since 30 October 2026. The console can still open one private E2EE tab key on your own seat; it shares the seat allowance and is deleted at the bell.

Models and prices§

A seat key reaches Venice's private and anonymized models. Every one, with its price and privacy label, is on /models, read by the keeper every hour.

Text models134on Venice
Image models51own price list
Video models150quoted first
Prices readHourlyby the keeper

Keeper catalog, 21 Nov 2026 05:11 UTC. The counts move with Venice's catalog.

Private

Venice labels these models as keeping no prompt or reply. That is the provider's policy, not something quotum can verify.

Anonymized

Claude, GPT and Gemini, and other entries labeled so, run through Venice. The upstream provider sees the prompt, without who sent it.

The label is per model id. Read it on /models for the exact model before you send.

What the cap buys

Pick a model and the tokens of one call. The estimate uses the prices the keeper last read from the catalog and the cap per key this session, and says how many such calls fit.

The input and output price of every text, image and video model a seat key can call, text in dollars per 1M tokens, is on Models. The cap per key this session is $0.24.

Open Models

The console's picks include Claude Sonnet 5.5, Grok 4.7 and GPT-6.1 Sol. The versions they replaced remain in the full catalog when Venice serves them. These picks are separate from the Pay as you go pilot list and the house board.

Records and payments§

Each seat's reported spend goes on chain in dollars, with its record hash. The chain cannot check two things: the provider's measurement behind that number, and the custodial payment to the provider.

Check a record against the chain

  1. Read the session's records/api/receipts?session=N has one row per seat. Spend per seat comes from the provider's usage API.
  2. Read the supplied hashPublic rows omit private fields. Their original hash can be matched to the chain event, but record preimage verification is incomplete.
  3. Match the eventThe keeper writes each row with report() as Reported(session, seat, usd, receiptHash) on the sink. Compare receiptHash with the supplied original hash; this does not verify the redacted preimage. Leftover is the seat's issued cap minus usd.

Where to read seat and Pay as you go records from an app: Check a record.

The payment path

  1. Claimthe tax lands in the sink, which has no withdraw path; 40% leaves at once for the OPS address
  2. Forwardthe keeper's forward() sends what is owed, as Forwarded
  3. Payment addressone published address, used for nothing else; read PAY_TO()
  4. Providerthe address converts and pays; every payment is posted on the home page with its tx

The 40% OPS share is the only other share from the seat sink, sent to one address fixed in the contract in the same transaction as the claim (Claimed(nvda, ops)); the split is on The cap. Nothing else leaves the sink but the provider's payment and the bell's buy. Pay as you go has separate net-margin accounting and its own OPS allocation, in Pay as you go.

What the keeper can do

  • Open a session
  • Report spend
  • Ring the bell
  • Forward what is owed
  • Release idle seats

What it cannot

  • Move a stake
  • Send NVDA anywhere but the payment address, the OPS address (its fixed 40% of each claim) and the pair

Where to check

Records
One row a seat a session, written by the keeper
/api/receipts?session=N, Reported
Usage
Cumulative sink burns since launch, then the recent bells with spend, burns and txs
/usage, /api/usage.json
The numbers
Burns, inference and backing through the latest completed bell
/stats
The house, live
One light for each live seat, with inference use and the daily bell
/live
OPS share
40% of every claim, in the claim tx
Claimed(nvda, ops)
Payment
What is owed, to one payment address, then the provider
Forwarded, PAY_TO() on the sink

Edge cases

  • Spend by a seat that leaves before the bell stays in today's usage and records, labeled apart from the on-chain bell total. It is paid from the provider balance, outside the sink's bell. A provider reserve protects call and house costs.
  • An unavailable keeper is not zero spend or an empty history: retry a failed usage read. Spend below one cent reads under $0.01.
  • On /usage, bell charts distinguish contract-reported inference from bought-and-burned amounts. Sponsored allowance and inference are reported separately from the regular-cap burn.
  • The deployer burned 28,604,787 QUOTUM on Sep 26 at 12:11 UTC. Its tx is linked on /usage. It was not a bell and is separate from the bell totals.

Contracts§

Everything runs on four addresses on Robinhood Chain: the coin, the staking contract, the sink and the price observer. The three of ours are immutable, with no owner and no admin withdraw.

Chain id4663Robinhood Chain
Addresses4the coin, three of ours
OwnerNonestaking, sink, observer
Admin withdrawNoneof any asset

Sources of all three are verified on Sourcify.

$QUOTUM0xFE936755185353b63a81dD72b47533Eb6021018Eexplorer

The coin, Pons v2, pair NVDA. Its trading tax goes to the sink. Listed on CoinGecko and DefiLlama.

QuotumStaking0x7F1d2b117aBac121f99cEED7f80e5925fFF37A53explorer

Stake, seats, queue, release.

TaxSink0x42AbC7b64eD47dB6899b4F01Aa6c765c600a53a2explorer

Tax recipient. Cap, bell, burn, forward.

PriceObserver0x8cBA8DA3E8174c4F6717570557974F2489Cd3d0Dexplorer

Session twap of the pair, nvda/usd read.

Payment addressread PAY_TO() on the sink contract 0x42AbC7b64eD47dB6899b4F01Aa6c765c600a53a2

The bridge to the provider, used for nothing else.

OPS addressread OPS() on the sink contract 0x42AbC7b64eD47dB6899b4F01Aa6c765c600a53a2

40% of every claim, fixed in the sink.

Events the page reads

Open(session, capUsd, tax24hUsd, liveSeats)
Right after each bell. On launch day, at launch
Reported(session, seat, usd, receiptHash)
Through the session
Burned(session, usd, nvdaIn, tokens, twap), Died(session, usd, reason), Bell(session, spentUsd, burnedUsd)
At 20:00 UTC
Forwarded(nvda)
When what is owed leaves for the payment address
Transfer to the zero address on $QUOTUM
The burn itself, readable in any explorer
SeatTaken, SeatQueued, SeatFreed, Idle
From the staking contract

Fixed addresses

Pons factory0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7eexplorer

Pons escrow0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9eexplorer

NVDA0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EECexplorer

Chainlink RHNVDA / USD0x379EC4f7C378F34a1B47E4F3cbeBCbAC3E8E9F15explorer

Verify it yourself§

The seat key is Venice's own. Point any client at api.venice.ai with it, and nothing of ours sits in between.

The key

The app configs point straight at api.venice.ai, not at us. Call the model list with your key and see what Venice serves you.

VeniceGET /models

A record

Match the supplied original record hash with the Reported event on chain; public record preimage verification is incomplete. The steps are in Records.

SinkReported

A record

Rebuild a wallet's seals from chain logs and bell records, and check them against the root posted after each bell.

verify.mjs--record

The key, direct

Shell
# your seat key, venice's own endpoint: nothing of ours in between
curl https://api.venice.ai/api/v1/models \
  -H "Authorization: Bearer your seat key"

The standard seat console goes through quotum and passes the model name as is. Its E2EE route runs on one private E2EE tab key on your own seat; it shares the seat allowance and is deleted at the bell.

A wallet's record

node verify.mjs --record <address> rebuilds the seals from chain logs and bell records and checks the record, its hash and its proof against the root posted on chain after each bell. Look one up at quotum.org/record.

  • The table. The top 25 or 50 wallets of the last root by seals held, then the highest tier, with the move since the root before (/api/record/top). The same seals and tier share a rank.
  • A row opens that wallet's record. It notes bells held in a row from 7, where held means 250,000 QUOTUM or more at the bell, and "since bell 1" when the wallet has held at every bell.
  • A lookup shows where the wallet stands and what the next rank takes.
  • Tiers are Copper, Silver, Gold, Diamond and Olympian. Seals pay nothing and do not change a seat's cap.
  • Around the table. The top three wallets have plaques. Replay rebuilds the previous bell, 17 seal filters narrow the table, and Rising lists wallets that climbed.

The call for agents§

An agent reads call.json and drafts the number. The seat wallet signs and sends it. An MCP server in one file reads the same JSON.

Deadline, UTC14:30the NYSE open
Reveal, UTC20:00at the bell
Calls1a seat a session
Salt32 bytesfresh every call

The call rules; 14:30 UTC from 2 Nov, 13:30 UTC under EDT. The live deadline is now.openAt in call.json.

The call is one number a seat seals before the NYSE open: a guess at what the Chainlink RHNVDA/USD feed on Robinhood Chain 4663 reads at the 20:00 UTC bell. It stays sealed until the bell, then every reader can check it. It is a number, not advice. An agent can read, compute and draft the call. The seat wallet signs it. An agent never holds the wallet.

  1. Readcall.json: the session, the deadline, the feed
  2. Sealthe seat wallet signs one line before the NYSE open
  3. Revealnumber, salt and signature open at 20:00 UTC
  4. Checkhash, signer, record and feed, from a public RPC

This section is about the call. To run an agent on a seat key, start from quotum.org/setup.

Read call.json

GET https://quotum.org/api/call.json, any origin, not cached. Version 1: fields are only added, never renamed. It holds the last 30 sessions with a call, newest first; ?session=N returns one.

now.session
The open session.
now.day
The day of its bell.
now.openAt
The deadline.
now.accepting
Whether calls are taken right now; next when they are not.
feed, rules
The Chainlink feed on 4663 and its page, at feed.address, 8 decimals; it moves in steps of about 0.5%. The rules on this page, in words.
sessions[].state
Open (calls taken), sealed (past the open), revealed (from the bell), void (no price that day).
sessions[].calls[]
One row per seat with seat, how, hash, sealed time and record. From the bell it adds the number, salt, text, spend and miss. Signature visibility depends on the signing kind; wallet, keeper and seat-key signatures are withheld.
sessions[].house[]
The house board with model, hash and sealed time. From the bell it has the same fields as a seat call.
sessions[].open, .bell, .burn
From the bell: the feed at the open (a free copy to compare with), the round the calls are scored against, and the bell's buy and burn.
house
On, models, ranked, revealed sessions. From 20 revealed sessions, a board by mean miss.

Seal a call

  • Text. One line, single spaces: quotum.org forecast <session> <price> <salt>.
  • Price. In USD with exactly two decimals, 1.00 to 10000.00.
  • Salt. 32 fresh random bytes as 0x and 64 lowercase hex, a new one every call, or the number could be guessed from the hash.
  • Signature. The seat wallet signs the line with personal_sign (EIP-191).
  • Deadline. The NYSE open of the bell day: 13:30 UTC under EDT, 14:30 UTC from 2 Nov. Trading days only; weekends and NYSE holidays have no call. The bell still rings on those days, see the session.
Shell
# the text the seat wallet signs
quotum.org forecast <session> <price> <salt>

# then one POST, content-type application/json
POST https://quotum.org/api/call
{"wallet": "0x…", "session": "6",
 "price": "228.90", "salt": "0x…", "sig": "0x…"}

# answer: {seat, hash, sealedAt, how, spentUsd}
# one call a seat a session, no edits, no cancel

Keep the salt and the text. The hash is keccak256 of the whole text in UTF-8. It is how you check your own call later without trusting us.

What is public, and when

Sealed

Before 20:00 UTC: the seat, the hash, the sealed time. The report() tx once it carries the hash on chain, within minutes of the seal.

Keeperreport()

Revealed

From 20:00 UTC: the number, the salt, the signed text, the reported cost and the miss in basis points; wallet, keeper and seat-key signatures are withheld.

call.jsoncalls[]

Scored

Against the last feed round at or before 20:00:00 UTC that day, from that day, above 0. With no such round the day is void and nothing is scored.

Feedbell

From session 11, revealed model calls include percentage moves and prices after each step. A rest row reconciles steps that miss the final number.

Call from your agent

An agent can call for its seat without the wallet. On the seat page, under the call, the holder picks Your agent, with the seat's Hermes Agent key and signs twice: first to see the seat's signing key, then the leave. The leave reads quotum.org call-leave <seat> agent on 0.00 <ts> seatkey <epoch> <address>, so it names the key that may sign for the seat, and stays until the holder signs it off or leaves the seat. The seat key signs messages only: it holds no funds and sends no transactions. A new epoch means a new key and a new leave. Then the agent sends its number with the seat's Hermes Agent key, before the NYSE open, one call a session. The keeper checks the key and the leave, draws the salt, and the seat key named in the leave signs quotum.org forecast-agent <session> <seat> <price> <salt>. The call carries the leave and its signature.

Shell
# the seat's Hermes Agent key is the only credential
POST https://quotum.org/api/call/agent
Authorization: Bearer <the seat's Hermes Agent key>
{"session": "11", "price": "182.43",
 "why": "gap holds into the close",
 "steps": [["pre-market gap", 0.8], ["chips firm", 0.4]],
 "up": "NQ holds", "down": "a soft print",
 "usdReported": 0.97}

# answer: {seat, hash, sealedAt, how: "agent", text}

Holder-authorized scheduled calls seal at a time between 12:30 UTC and the NYSE open, signed by the seat key the leave names; giving leave does not seal immediately.

What an agent call proves

  • Which key signed it, and that the seat's holder at the anchoring block named that key in a signed leave

What it does not

  • To anyone else, which seat sent it: we could have written the call ourselves
  • The line, the steps and the cost: they ride beside the call, outside the signed text, on our word only

The cost on the row is the agent's own count, usdReported. Beside it sits usdKey, what the seat's agent keys had spent this session at the last read from Venice before the seal, with the time of that read. It includes anything else the key did that day. The keeper reads Venice every minute, and a failed read leaves the last good one, so check the time.

The MCP server

One file, node 18 or newer, no dependencies, read only. It reads call.json and nothing else. No tool writes, signs or holds a key.

  • call_sessions: the latest sessions, one line each.
  • call_session: one session in full.
  • call_how_to_seal: the text to sign with today's session filled in, the formats, the deadline.
Shell
# the server is one file, served here
curl -O https://quotum.org/call-mcp.mjs

# stdio: any client that starts a process
claude mcp add quotum-call -- node /path/to/call-mcp.mjs

# http: one server for several agents on the same machine
node call-mcp.mjs --http 8811
claude mcp add --transport http \
  quotum-call http://127.0.0.1:8811/mcp

rh-preflight as an MCP server

rh-preflight, our Hermes Agent plugin, also runs as an MCP server over stdio for Claude Code, Cursor, Claude Desktop and other MCP clients. Python 3.11 or later, no runtime dependencies, read only. No keys required: it never signs or pays, holds no wallet keys and runs without a wallet. It is not a safety oracle and does not call a token good or bad.

  • builder_card: the public builder card for an address, a project or a repo_url, at least one. The builder record is by HEY Research Lab, co-author.
  • tx_check: an unsigned to plus data or value, optional from, chainId 4663, or a tx_hash. Returns action: pass, ask, block or note, with a live Hookr read where it applies. Advisory: your client decides whether to go on.
Shell
# python 3.11 or later, then add it to Claude Code
pip install rh-preflight-mcp
claude mcp add --transport stdio rh-preflight -- rh-preflight-mcp

Cursor in .cursor/mcp.json, Claude Desktop in claude_desktop_config.json:

JSON
{
  "mcpServers": {
    "rh-preflight": {
      "command": "rh-preflight-mcp",
      "args": []
    }
  }
}

Without a pip install, uvx rh-preflight-mcp runs it: claude mcp add --transport stdio rh-preflight -- uvx rh-preflight-mcp. In Hermes Agent, install the plugin instead: hermes plugins install rh-preflight.

Check a call

  • Hash. Rebuild the supported forecast text forms from the session, seat or model, price and salt. One keccak256 must equal hash.
  • Signer. The current public policy withholds wallet, keeper and seat-key signatures. Holder-authorized agent calls use the seat key named in the signed leave. Check the commitment and the report() that anchored it before openAt; public signature and record preimage checks remain incomplete.
  • Record. Open the record to find the report() that carried the hash, mined before openAt.
  • Feed. Read the feed's rounds back to the last one at or before 20:00:00 UTC, and it is bell.

Or run the verifier. call.jsonl has one line for every revealed call, oldest first. verify.mjs checks the price and salt commitment, session day, feed rounds and miss from a public RPC. It can locate the original record hash in a Reported event. Signatures and private record fields are omitted, so signature and record preimage checks report incomplete. An incomplete proof is never reported as passed.

Shell
# one line per revealed call, any origin, not cached
curl https://quotum.org/api/call.jsonl

# the verifier: node 20 or newer and viem
curl -O https://quotum.org/verify.mjs && npm i viem
node verify.mjs --session 11

The house board

On some days the keeper also asks a few private Venice models for the same number, paid by quotum, with web search. Each answer is sealed like a seat call under its own text, quotum.org forecast-house <session> <model> <price> <salt>, signed by the keeper. House rows sit apart from the seats (house in call.json) and open at the same bell. No ranking of the models before 20 revealed sessions.

The reference runner. One house row, ensemble-v0, is not one model. Two researchers write a brief, one with live web and X search, one with web search. Five forecasters call from it, a critic reads their five numbers without their names, and the five revise once. The sealed number is the median. A measured run cost about $1, paid by quotum, with the runner ceiling of $1.40, and its cost is on its row like any other. The runner is one file, MIT, at quotum.org/ensemble.mjs. Fork it and change the models.

The house uses a separately budgeted day key cut from the ops seat. It is not a holder day key; those are off, see day keys. Code defaults include Kimi K3, Grok 4.7, GLM 5.3, DeepSeek V4 Pro, Qwen 3.8 and ensemble-v0. Read call.json under house.models for the enabled set. This budget is separate from the reference runner's own ceiling.

Hermes Agent§

Hermes Agent runs on a seat with the quotum provider plugin; hermes usage then shows the seat's cap, the spend, what is left and the 20:00 UTC bell.

Plugin0.3.1latest in use
Install3 linesplugin, key, provider
Hermes Agent key, from$1up to the seat's cap
LicenseMITsource on GitHub

Plugin version from the keeper's per-version meter, usage.json, 9 Nov 2026. Key amounts from the seat page.

Install. Get a Hermes Agent key, or the seat key, from the seat page under Other apps with the seat wallet's signature. Then three lines.

Hermes Agent
hermes plugins install qvotvm/hermes-quotum --enable
echo 'QUOTUM_SEAT_KEY=<your key>' >> ~/.hermes/.env
hermes config set model.provider quotum && hermes config set model.default kimi-k3

The Hermes Agent key

  • On the seat page, under Other apps and Hermes Agent, the seat wallet signs for one Hermes Agent key and picks an amount, $1 up to the seat's cap.
  • Each session the Hermes Agent key gets that amount off the seat's cap. What it leaves unspent goes to the bell with the rest of the seat.
  • Sign again to see the key again or to revoke it. A freed seat loses its Hermes Agent key.
  • Put the Hermes Agent key in QUOTUM_SEAT_KEY in place of the seat key.

What goes where

api.venice.ai
The prompts, with the key. Hermes Agent sends them straight to the provider.
quotum.org
A short hash of the key, to read the meter. Never the key itself or a prompt.
The keeper
Counts spend per key hash, per day and per plugin version, and nothing else.
The models
Private and anonymized models on Venice; the label is per model.

Seat use is provider-reported. A seat number alone does not establish who operates it. The terms apply to every key.

Source

The plugin is open source, MIT. Read it before you give it a key.

The downloadable morning-digest setup reports a failed X API read as an error, not a quiet window.

The mechanics§

One session from the open to the burn, walked through on the real numbers of session 24, 19 October 2026.

Cap a seat$0.8413 seats, $10.97 in all
Spent$3.236 seats, 102 requests
Not spent, burned$7.75bought at the bell
Burned139,653QUOTUM, in the bell tx

Session 24, 19 Oct 2026: the record and the bell tx.

  1. Taxtrading tax on the pair, collected in NVDA
  2. Capset at the open, the smallest of three numbers
  3. Spendthe seats draw it down with their keys
  4. Bell20:00 UTC, each key's spend on chain
  5. Burnthe unspent buys QUOTUM and burns it

The rules live in their own sections: the cap for the three bounds and the 40/60 split, the bell and the burn for the buy, the guard and every case where nothing burns. Below is one session of them at work.

Session 24, step by step

  1. StakeYour wallet

    A wallet stakes 2,500,000 QUOTUM and takes a seat. The seat.

    EventSeatTaken

  2. KeyKeeper

    The seat gets a Venice key for private and anonymized models, the label shown before sending. External apps call Venice directly. The key.

  3. OpenSink

    Session 24 opened at $0.84 a seat, 13 seats, $10.97 in all. That is the common cap at the open; a seat taken later can get less when less funding remains.

    EventOpen

  4. SpendSeats

    Six of the 13 seats used their keys: $3.23 in all, 102 requests, 7.5M tokens in, 94k out. A key works across bells while it has allowance.

  5. BellKeeper, 20:00 UTC

    The keeper reported what each key spent to the chain and rang the bell. The next cap was set right after.

    EventsReported Bell

  6. BurnSink, in the bell tx

    The $7.75 not spent bought 139,653 QUOTUM on the pair and burned it. A burn needs NVDA in the sink, a leftover of at least a dollar and the price guard's yes; a refused buy stays in the sink.

    EventBurned

Every number above is in the session 24 record and the bell tx: $10.9708 cap less $3.2252 spent leaves the $7.7456 that burned.

The measure§

The unit is $QUOTUM itself: nothing is minted, there is no second token, and the supply only goes down.

What a bell can do

  • Spend at most the unspent cap, and only the NVDA the tax already paid into the contract
  • Buy $QUOTUM on the pair at the pair's price
  • Burn it with the token's own burn(); the Burned event carries the dollars, the NVDA and the tokens
  • Lower totalSupply by exactly that; the home page reads both

What never happens

  • A mint
  • A second token or unit
  • A buy more than 10% plus fees over the day's average price

Where it trades. Graduated to its Uniswap v4 pool. The bell buys there. Pools others open are not ours.

FAQ§

Short answers to what people ask most; each one links to the section that holds the full rule.

Is it real

Is there an airdrop or a claim?
No. quotum has no airdrop, claim or eligibility check. Seats are only taken on quotum.org, and we never ask you to connect a wallet anywhere else.
“The cap is fake, you'll stop topping it up.”
The cap is a formula over the tax, which lands in a contract with no withdraw path. The one uplift so far, the QIP-1 floor for sessions 27 to 40, was voted by holders, paid from the sink reserve, and has ended. If the tax dies the cap prints $0 and the page says so. The cap
Can it rug?
The staking contract and the sink have no owner and no withdraw, and unstake works at any time. The coin's price can go to zero, but nobody can take the stake. Contracts
Does a seat pay anything out?
No. Nothing is paid out. The seat gets a cap it can spend, and no token. Unstake returns the stake and nothing else. It is capacity to spend.
Is it circular, or a vamp?
One coin, one pair, one tax: the tax buys inference, and what the seats did not spend can buy the coin and burn it. That is the whole loop. The measure
Is this a clone of Aria or Venice?
No. We are a customer of Venice and did not fork a token: no bond, no second unit, no mint rate. The measure

The coin and the tax

Where does the tax go?
Into a contract: 40% of every claim to the OPS address at once; of the 60% that stays, spent cap pays for inference and unspent cap goes to the bell's buy and burn. All three are events on the home page. Where the money comes from
What is it paired with?
NVDA on Pons. The tax lands in NVDA. The cap is quoted in dollars of the provider, never in shares.
Can I buy QUOTUM in another pool?
You can, but only the Pons QUOTUM/NVDA pair pays the trading tax that funds the seats and feeds the bell. Other QUOTUM pools and wrappers are not ours, and some charge very high fees, so check the pool before you swap.
Is supply locked?
The launch share is burned, tx in the launch thread, and later bells can burn more. Each seat locks 2,500,000 QUOTUM by choice and can leave any time. The seat
What if nobody spends?
Then the whole cap, as far as the tax paid for it, goes to the bell's buy and burn, and nothing goes to the provider that session. The page shows it. The bell and the burn
Is this a faucet?
No. A faucet gives it away; a seat costs a 2,500,000 QUOTUM stake, the cap is whatever the tax collected, at most $50, and the key goes with the stake. The seat

Using a seat

How big is a seat?
2,500,000 QUOTUM, 0.25% of the supply at deploy. A hundred seats, then a queue that reads from the chain. The seat
Why 20:00 UTC, and why every day?
The chain and the key run all week, so the bell does too, at a fixed hour a clock can be set by. It is the NYSE close under New York summer time; from 2 Nov the close is 21:00 UTC and the bell stays at 20:00 UTC. The session
What does each privacy label mean?
Private means Venice states it keeps no prompt or reply, which is the provider's policy; anonymized means the upstream provider sees the prompt, without who sent it. Read the label per model before sending. Models and prices
Is there a demo?
The key works from any OpenAI-compatible client, and the quickstart has the snippet with a real reply. The record shows provider-reported dollar spend; token counts show only where coverage is complete. Quickstart

Pay as you go§

Pay as you go was an optional pilot beside seats: one wallet prepaid USDG, revocable agent keys spent it through an OpenAI-compatible endpoint, and every charge has a record.

A request$0.25at most
Markup25%over provider cost
Unused balance$50a project, more for holders
Input limit8,192bytes, more with long context

Published pilot limits. /api/payg/v1/models has the admitted limits and prices live.

  1. Enrollan invite or a 0.1% holder wallet, one signed challenge
  2. FundUSDG on 4663, spendable after 20 blocks
  3. Keyspend-only project keys, 14 days by default
  4. CallOpenAI-compatible, a record for every charge

No seat is required.

Enroll and fund

Register one funding wallet through a fresh domain-bound wallet challenge. Direct USDG transfers on chain 4663 become spendable after 20 matching canonical blocks. Funding uses no deposit contract and requires an approved wallet and open intake. Unapproved or excess transfers stay held and can be requested back. Unused balance returns only to the funding wallet with a fresh signature, normally within 24 hours; withdrawals wait during reconciliation. x402 top-ups are later work. Custody, refund and cancellation terms.

Keys and limits

Agent keys
Revocable, spend-only project keys with model and daily limits. They default to 14 days, at most 30. A key serves the models picked when it was made; a model added later is not on older keys, so make a new key for it.
Console sessions
Wallet-signed, at most 24 hours, with a $2 limit, raisable to $5.
Unused balance
The default cap is $50 per project, $100 for eligible 0.1% holders and $200 for eligible 0.5% holders, with a separate $500 limit across projects.
Price
Actual USD plus DIEM provider cost, marked up 25%, bounded by the admitted hold and $0.25 per request. Both prompt/tools and output/reasoning enter the bound.
Input
Counted in bytes, not tokens: the UTF-8 bytes of the canonical JSON of messages, tools and tool_choice, plus 512, plus 256 per message, plus 1,024 if tools are sent. The limit is 8,192 bytes, or 32,768 if we turn long context on for that project. Under 8,192 one plain message without tools fits about 7 KB of text. Over the limit: 400 input-limit, nothing charged.
Output
max_tokens is optional. The pilot defaults to and accepts at most 2048 output/reasoning tokens, bounded by the model's own limit; reasoning_effort is at most medium. /api/payg/v1/models has the admitted limit of each model.
Units
Charges and meter values use integer USD nanodollars; divide by 1,000,000,000. USDG transfers use six decimals.
Your users
Project keys may serve your own app's users under the Pay as you go terms; keep them on your server. This does not permit resale or sharing of raw gateway access or seat/day keys.

The call

Set an OpenAI client's base_url to https://quotum.org/api/payg/v1 and send a unique Idempotency-Key header per logical request (the retry rule). Text-model function/tool messages only. Web search is off in the pilot. Image, video, TTS and embedding endpoints are outside the published text pilot.

HTTP
POST /api/payg/v1/chat/completions
Authorization: Bearer <local project key>
Idempotency-Key: <unique request id>

{
  "model": "openai-gpt-6-luna",
  "messages": [
    { "role": "user", "content": "hello" }
  ],
  "max_tokens": 256,
  "stream": true
}
GET /models
Fresh prices and privacy labels.
GET /meter
Available and held prepaid balance.
GET /receipts/<id>
Durable billing for one request.

Request outcomes

400
An invalid request or an unsupported pilot option.
401 403
Authentication errors.
402
Insufficient unused balance or a console session limit.
429
A project or key daily budget.
202 200
A retry with the same project, body and Idempotency-Key: 202 while open, 200 when closed.
409
A changed body with an Idempotency-Key already used.

Admission errors are not charged. Once a stream starts, its HTTP status stays 200 even if it later reports an error or closes early. The last billing event, or the record if the connection breaks, tells you whether the request was charged, failed or is still pending. A successful reply can contain no visible text when reasoning used its token budget.

Example

Python with the OpenAI SDK, its own retries off (max_retries=0). Each answer carries its record in quotum_billing.

Python
import uuid
from openai import OpenAI

client = OpenAI(
    base_url="https://quotum.org/api/payg/v1",
    api_key="your project key",
    max_retries=0,
)
r = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "hello"}],
    max_tokens=256,
    extra_headers={"Idempotency-Key": str(uuid.uuid4())},
)
print(r.choices[0].message.content)
bill = r.quotum_billing
print(bill["id"], f"${bill['charge'] / 1e9:.6f}")

Models

Read /api/payg/v1/models for admitted limits, current prices and availability. The eleven pilot ids are gemini-4-argon, z-ai-glm-5-3-flash, zai-org-glm-5-2, openai-gpt-oss-120b, kimi-k3, deepseek-v4-flash, deepseek-v4-1-flash-1017, muse-spark-open, openai-gpt-6-luna, minimax-m3-1-flash and nvidia-nemotron-3-5-super-vl-120b-a12b. An allowlisted id is not the same as a calibrated and available one: the models endpoint says which are live. kimi-k3, muse-spark-open and gemini-4-argon are premium, priced above the rest.

  • Privacy. GPT-6 Luna and Gemini 4 Argon are labeled anonymized in the Venice catalog. The other pilot models, MiniMax M3.1 Flash, Nemotron and Muse among them, are private. The gateway sees plaintext. What the labels mean.
  • Reasoning. minimax-m3-1-flash reasons by default: with a small max_tokens the reasoning can take the whole budget and the reply comes back empty but charged (64 tokens asked, 61 went to reasoning, no text). Send "reasoning_effort": "none" or max_tokens of 512 or more.
  • Effort field. An explicit reasoning_effort needs a model that supports it; gemini-4-argon accepts the field only when it is left out.

Holder access

During the pilot, a wallet with at least 0.1% of QUOTUM supply, counting QUOTUM staked in its seat, could enroll with no invite. Its project can keep up to $100 unused instead of $50, and up to $200 from 0.5%. The balance is checked at enrollment and at each top-up against supply at that moment, so the token count moves as supply burns. Each top-up uses the cap of the tier the wallet is in at that moment, and $50 below 0.1%. Nothing is locked. It pays holders nothing; it only changes enrollment and the unused cap. Credited balance and withdrawals stay as they are.

Margin and burns

60% of realized positive cumulative net Pay as you go margin, after refunds, supplier consumption, losses, measured expenses and reserves, is allocated to a separate published wallet's 20:00 UTC QUOTUM buy and burn(). 40% goes to OPS. No burn amount or date is promised, and quotum may change or stop the burn.

Pay as you go burns have not started yet. Until they do, that 60% waits in the ledger as allocated batches. Unknown costs and unused deposits contribute no burn margin. A paid request shows $0 for the buy and burn on its record while Pay as you go's cumulative costs and reserves are still above revenue. There is no positive margin to split yet. Operator accounting and chain records stay separate from the seat bell.

Pay from a wallet§

Pilot, paused

One model call paid by one USDG signature from a wallet, with no project and no key. The pilot ran from 29 October to 12 November 2026 and is paused.

The pilotPackages, sponsorship and the example below describe the pilot as it ran. Prices and limits came from the live quote.

One model call, one USDG payment, no project and no key. A funded wallet signs a payment for a fixed text package. It runs on the x402 pattern: a valid first request returns 402 with a quote, and the second carries the signed payment. The answer may arrive immediately or remain pending.

Packages
deepseek-v4-1-flash-1017 at a fixed 0.003072 USDG and kimi-k3 priced from the live catalog in each quote (0.043200 USDG at the last published quote), each for up to 4,096 input bytes including framing and 1,024 output tokens including reasoning. The charge is the quoted package price: no balance, no change, no credit for what the answer did not use. GET https://quotum.org/api/payg/v1/request/packages lists the live packages and prices.
Pilot
Settlement gas for the DeepSeek package is sponsored within a finite pilot budget, 100 settlements in all and 20 per UTC day. When it runs out, quotes for that package close. Kimi K3's price includes its own settlement.
Payment
USDG on Robinhood Chain (chain 4663), asset 0x5fc5360d0400a0fd4f2af552add042d716f1d168, six decimals. Bring an EOA wallet and an EIP-712 signer for a native USDG EIP-3009 authorization; contract wallets are not supported. Before signing, check the network, the asset, the payTo address and an explicit spend cap against the live quote.
The call
POST https://quotum.org/api/payg/v1/request/chat/completions with an OpenAI-style text body. Streaming, tools and search are not supported. Invalid request fields return 400; input or output over the package limit returns 413. Neither produces a payment challenge. The 402 answer carries a base64 PAYMENT-REQUIRED header and the same JSON body; a quote lasts 120 seconds. Resend the same body with the signed payment, base64 x402 v2, in the PAYMENT-SIGNATURE header. openapi.json covers this chat route and the package list; recovery is described in the x402 manifest and below.
Answers
200 returns choices, usage and quotum_billing with the operation id, payment, fulfillment, amount, currency, accounting and the output's expiry. 202 carries Retry-After and billing while payment, fulfillment or a refund is pending; a 202 is not proof of delivery or of a refund. Without a recovery capability, an included or confirmed payment sent again returns 409 payment_already_used without output.
Recovery
A plain HTTP client gets the response and nothing more: there is no automatic output recovery. A client that saves a 32-byte X-Quotum-Recovery capability before it sends, together with X-Quotum-Payer and a stable Idempotency-Key, can read the encrypted output for 24 hours: GET https://quotum.org/api/payg/v1/request/operations/<operationId> reads private billing, and /output after it returns the saved answer with the X-Quotum-Recovery header. Never publish that header or the buyer journal. Losing the capability means no automatic recovery.
Refunds
Manually reviewed full refunds within 24 hours after a known failure, or after the 30-minute deadline for resolving an unknown outcome.
Request binding
The quote binds the request body and retry headers when you use its authorization nonce. Keep the same body, payment, recovery capability and Idempotency-Key for a retry. The payment signature authorizes a USDG transfer; it does not sign the request body. An optional EIP-712 body commitment can be sent in the X-Quotum-Body-Commitment header.
Privacy
The gateway sees plaintext. Requests are saved encrypted to complete paid calls; no automatic deletion time is set for admitted requests. Saved output is encrypted and kept for 24 hours.

Errors

  • 400 request_invalid, payment_invalid, recovery_invalid, commitment_invalid.
  • 404 route, operation_not_found. 405 method. 415 request_invalid.
  • 409 authorization_order_conflict, quote_binding_conflict, payment_already_used, commitment_conflict.
  • 410 quote_expired, output_expired. 413 work_bound_exceeded, output_limit.
  • 422 payment_invalid, payment_window, wallet_not_payable, token_paused, payer_frozen, insufficient_usdg, commitment_resource, commitment_nonce, commitment_body, commitment_quote, commitment_expired, commitment_window, commitment_signature, commitment_signer.
  • 429 preflight_busy, preflight_limit, preflight_expired, quote_storage_limit, quote_limit, payer_limit.
  • 503 price_stale, model_unavailable, sponsor_exhausted, settlement_unavailable, refund_gas_unfunded, refund_backing_shortfall, reservation_missing, resource_version_stale, chain_mismatch, token_domain_mismatch, intake_halted, supplier_capacity, tolerance_unbacked, refund_backing_unattested, loss_budget.

Example

Two requests with the same body. The first returns 402 and the quote in the PAYMENT-REQUIRED header. Check it, sign the USDG transfer it describes, and send the body again with the payment in PAYMENT-SIGNATURE. Node 20 with viem for the EIP-712 signature; any EIP-3009 signer works. The key comes from your own wallet setup, never from code.

Node
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.BUYER_KEY);
const PAY_TO = 'the treasury address you verified'.toLowerCase();
const USDG = '0x5fc5360d0400a0fd4f2af552add042d716f1d168';
const url = 'https://quotum.org/api/payg/v1/request/chat/completions';
const body = JSON.stringify({ model: 'deepseek-v4-1-flash-1017', messages: [{ role: 'user', content: 'say hello in one sentence' }], max_completion_tokens: 1024, stream: false });
const json64 = (v) => Buffer.from(JSON.stringify(v)).toString('base64');

// 1. ask: 402 and the quote
const quote = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body });
const required = JSON.parse(Buffer.from(quote.headers.get('PAYMENT-REQUIRED'), 'base64').toString());
const r = required.accepts.find((a) => a.network === 'eip155:4663' && a.asset.toLowerCase() === USDG);

// 2. check before signing: network, asset, payTo and your spend cap
if (!r || r.payTo.toLowerCase() !== PAY_TO || BigInt(r.amount) > 3072n) throw new Error('unexpected quote');

// 3. sign the USDG transfer authorization (EIP-3009) with the nonce the quote issued
const now = Math.floor(Date.now() / 1000);
const authorization = { from: account.address, to: r.payTo, value: r.amount, validAfter: String(now - 1),
  validBefore: String(Math.min(now + r.maxTimeoutSeconds - 1, r.extra.quoteExpiresAt)), nonce: r.extra.authorizationNonce };
const signature = await account.signTypedData({
  domain: { name: r.extra.name, version: r.extra.version, chainId: 4663, verifyingContract: r.asset },
  types: { TransferWithAuthorization: [{ name: 'from', type: 'address' }, { name: 'to', type: 'address' }, { name: 'value', type: 'uint256' },
    { name: 'validAfter', type: 'uint256' }, { name: 'validBefore', type: 'uint256' }, { name: 'nonce', type: 'bytes32' }] },
  primaryType: 'TransferWithAuthorization',
  message: { ...authorization, value: BigInt(authorization.value), validAfter: BigInt(authorization.validAfter), validBefore: BigInt(authorization.validBefore) },
});

// 4. the same body again, with the payment
const payment = { x402Version: 2, accepted: r, resource: required.resource, payload: { signature, authorization }, ...(required.extensions ? { extensions: required.extensions } : {}) };
const answer = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', 'PAYMENT-SIGNATURE': json64(payment) }, body });
console.log(answer.status, await answer.json());

This is a plain client: keep the answer when it arrives. After an interruption, resend the same signed request unchanged; never sign a second payment for the same request. Without a recovery capability, an included or confirmed payment sent again returns 409 payment_already_used without output, and a 202 means wait and read Retry-After, not pay again.

Machine-readable: openapi.json, the x402 manifest (quotum's own auxiliary manifest, not an x402 standard) and llms.txt.

Glossary§

Every term the docs lean on, in one line each, with the section that explains it.

Seats

Seat
One of a hundred places, taken by staking 2,500,000 QUOTUM from one wallet. It comes with one key. The seat
Stake
The QUOTUM held in the staking contract for a seat, fixed at deploy. Unstake any time; under 2,500,000 the seat frees. The seat
Queue
Wallets that staked while all hundred seats were taken. The head moves in when a seat frees. The seat
Idle
Two sessions in a row at $0 while someone waits: the seat moves to the tail of the queue. The stake is not touched. The seat
Session
From one 20:00 UTC bell to the next. The cap is set at its open and counted at its bell. The session
Cap
What a seat's key can spend in one session from the trading tax, in dollars: the smallest of $50, the seat's share of 60% of the last 24 hours of trading tax, and 0.25% of the supply at the previous session's average price. No floor is active now. In a sponsored session the key gets the sponsor's amount on top of the regular cap: the regular cap is spent first, and what the sponsor's part leaves unspent is not burned. The record file of the session lists the granted and spent amounts under sponsor. What is not spent does not carry over. The cap
Seat key
A Venice API key for one seat. In another app it calls Venice directly; in the console it passes through our server, which records no prompt or reply. The keeper meters its spend. The key

The bell

Bell
20:00 UTC every day. The keeper reports each key's spend on chain; with the unspent part the sink tries to buy QUOTUM and burn it, where the price guard allows. The bell
Burn
The token's own burn() on QUOTUM bought with the unspent cap in the bell tx, when the sink holds the NVDA and the price guard allows. Nothing is minted; the supply only goes down. The measure
Price guard
No buy above the pair's time-weighted price plus 10% and the pair's fees. A refused buy is emitted as Died and its NVDA stays for the next bell. The bell, in order
Sink
The contract that receives the coin's trading tax. It forwards what the seats spent to the payment address and uses the unspent for the guarded buy and burn. It has no admin withdraw path. Contracts
Keeper
quotum's server. It issues each seat's key, meters its spend against the cap, and at the bell reports each seat's spend on chain and calls the bell. The bell
Payment address
The one published address the spent part is forwarded to, which pays the provider. Read it as PAY_TO() on the sink. Records and payments
Backing
A holder-voted round recorded beside the cap. It never reaches the keys and does not burn as unspent cap. None is active now. Backing is not cap

Records and paying without a seat

Record
Each seat's spend for a session, with its hash on chain in Reported. Per session at /api/receipts?session=N. Records and payments
QIP
A holder vote on a change, such as QIP-1's floor or QIP-5's backing round. Governance
PAYG
Pay as you go: a prepaid project balance in USDG with its own API key, for agents without a seat. Separate from the seats and their caps. Paused since the pilot ended on 12 November 2026. Pay as you go
Pay per request
Paying quotum for one model call from a wallet, with no key, over x402. A pilot that ran until 12 November 2026, now paused. The facilitator, where quotum settles x402 payments for other sellers, is a separate pilot with its own status. Pay from a wallet

A seat for
the next bell

Daily at 20:00 UTC

The bell rings every day at 20:00 UTC.

Scheduled time. Settlement is recorded separately.

Take a seat

Contents

Search the docs

Arrow keys to move. Enter to open. Escape to close.