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
Or install in Hermes Agent
hermes plugins install qvotvm/hermes-quotum --enable- QUOTUM_SEAT_KEY from Your seat, Other apps: a seat key or the seat's Hermes Agent key.
- 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
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://.
Set the environment variable, then run this cURL request. It prints the provider's JSON reply.
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}'For Python, run python3 -m pip install openai, save this as seat-call.py and run python3 seat-call.py in the same shell.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.venice.ai/api/v1",
api_key=os.environ["QUOTUM_SEAT_KEY"],
)
r = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[{"role": "user", "content": "hello"}],
max_tokens=256,
)
print(r.choices[0].message.content)Expect a greeting. The wording varies. cURL returns it in choices[0].; 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": { … }
}
- The reply.
choices[0].message.content; Python prints it. - The model's reasoning, apart from the reply. Here 74 of the 85 completion tokens.
- 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. - 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://. 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.
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}'For Python, run python3 -m pip install openai, save this as payg-call.py and run python3 payg-call.py in the same shell.
import os
import uuid
from openai import OpenAI
client = OpenAI(
base_url="https://quotum.org/api/payg/v1",
api_key=os.environ["QUOTUM_PAYG_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}")Expect a greeting, then a record ID and the actual dollar charge. Wording and cost vary. cURL returns choices[0]. 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_, 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_ in the response. Read https:// 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://, and the same rows as a file at https://; 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:// 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 /. 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.
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.
- Stake2,500,000 QUOTUM in the staking contract
- Seatone of a hundred, one key
- Sessionbell to bell, 24 hours
- Capthe smallest of three numbers
- 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.
- Ceiling$50a session, fixed in the sink
Open(session, capUsd, …) - Tax share60%of the last 24 hours of trading tax, divided by the seats live at the open
Open(…, tax24hUsd, liveSeats) - Seat value0.25%of the supply at the last session's average price, from the PriceObserver
the observer
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:
OPS_BPS 400060% the seats' cap and the burnIf 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.
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 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
report()KeeperFor 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.
Event
Reportedbell()KeeperThe sink adds up not spent = cap − spent over every live seat.
Event
BellBuy 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.Event
BurnedPrice 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.
Event
Diedwith the reasonforward()KeeperThe 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.
Read
PAY_TO()on the sink

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 2026Holder 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.
SavedSaved figures, the live read replaces them
- Issuedafter
SeatTaken, for private and anonymized models - Limitedto the session's cap, metered at Venice
- Renewedseven days before the 90-day limit
- 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.
# 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://Calls Venice directly and spends the seat's daily allowance.api. venice. ai/ api/ v1 - Pay as you go project key
https://Paused. 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.quotum. org/ api/ payg/ v1
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.
Hermes Agent
The quotum provider plugin. hermes usage then shows the seat's cap, the spend, what is left and the bell.
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 appsDeepSeek 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 quickstartLangChain
No LangChain-specific guide on this page. Use its OpenAI-compatible chat client with the seat-key endpoint and the seat key.
Seat-key quickstartGoose, Open WebUI, curl
Each has a config on the seat page too, key masked until the seat wallet signs.
Your seatE2EE§
Day keys offHolder 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.
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 ModelsThe 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
- Read the session's records
/has one row per seat. Spend per seat comes from the provider's usage API.api/ receipts? session= N - Read the supplied hashPublic rows omit private fields. Their original
hashcan be matched to the chain event, but record preimage verification is incomplete. - Match the eventThe keeper writes each row with
report()asReported(session, seat, usd, receiptHash)on the sink. ComparereceiptHashwith the supplied originalhash; this does not verify the redacted preimage. Leftover is the seat's issued cap minususd.
Where to read seat and Pay as you go records from an app: Check a record.
The payment path
- Claimthe tax lands in the sink, which has no withdraw path; 40% leaves at once for the OPS address
- Forwardthe keeper's
forward()sends what is owed, asForwarded - Payment addressone published address, used for nothing else; read
PAY_TO() - 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 - OPS share
- 40% of every claim, in the claim tx
Claimed(nvda, ops)
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.
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
Transferto the zero address on $QUOTUM- The burn itself, readable in any explorer
SeatTaken,SeatQueued,SeatFreed,Idle- From the staking contract
Fixed addresses
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
# 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.
- 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 (
/). The same seals and tier share a rank.api/ record/ top - 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.
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.
- Read
call.json: the session, the deadline, the feed - Sealthe seat wallet signs one line before the NYSE open
- Revealnumber, salt and signature open at 20:00 UTC
- 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.
Read call.json
GET https://, 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;
nextwhen 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
0xand 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.
# 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 cancelKeep 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.
# 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_: the text to sign with today's session filled in, the formats, the deadline.how_ to_ seal
# 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/mcprh-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 anaddress, aprojector arepo_url, at least one. The builder record is by HEY Research Lab, co-author.tx_check: an unsignedtoplusdataorvalue, optionalfrom,chainId4663, or atx_hash. Returnsaction:pass,ask,blockornote, with a live Hookr read where it applies. Advisory: your client decides whether to go on.
# 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-mcpCursor in .cursor/mcp.json, Claude Desktop in claude_desktop_config.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 beforeopenAt; public signature and record preimage checks remain incomplete. - Record. Open the record to find the
report()that carried the hash, mined beforeopenAt. - 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.
# 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 11The 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.
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.
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 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-k3The 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_KEYin 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.
- Hermes Agent plugin: connect Hermes Agent to a seat.
- Hermes Agent house calls: call the house from Hermes Agent.
- QIP-1 records: read the record source.
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.
Session 24, 19 Oct 2026: the record and the bell tx.
- Taxtrading tax on the pair, collected in NVDA
- Capset at the open, the smallest of three numbers
- Spendthe seats draw it down with their keys
- Bell20:00 UTC, each key's spend on chain
- 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
StakeYour wallet
A wallet stakes 2,500,000 QUOTUM and takes a seat. The seat.
Event
SeatTakenKeyKeeper
The seat gets a Venice key for private and anonymized models, the label shown before sending. External apps call Venice directly. The key.
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.
Event
OpenSpendSeats
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.
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.
Events
ReportedBellBurnSink, 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.
Event
Burned
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(); theBurnedevent carries the dollars, the NVDA and the tokens - Lower
totalSupplyby 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.
Published pilot limits. / has the admitted limits and prices live.
- Enrollan invite or a 0.1% holder wallet, one signed challenge
- FundUSDG on 4663, spendable after 20 blocks
- Keyspend-only project keys, 14 days by default
- 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_tokensis optional. The pilot defaults to and accepts at most 2048 output/reasoning tokens, bounded by the model's own limit; reasoning_is at mosteffort medium./has the admitted limit of each model.api/ payg/ v1/ models - 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:// 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.
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.
401403- Authentication errors.
402- Insufficient unused balance or a console session limit.
429- A project or key daily budget.
202200- A retry with the same project, body and
Idempotency-Key: 202 while open, 200 when closed. 409- A changed body with an
Idempotency-Keyalready 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.
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}")The same request with curl. GET /receipts/<id> with the same key reads the record later.
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}'Models
Read / 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-flashreasons by default: with a smallmax_tokensthe 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_oreffort": "none" max_tokensof 512 or more. - Effort field. An explicit
reasoning_needs a model that supports it;effort gemini-4-argonaccepts 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, pausedOne 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-1017at a fixed 0.003072 USDG andkimi-k3priced 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://lists the live packages and prices.quotum. org/ api/ payg/ v1/ request/ packages - 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://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 base64quotum. org/ api/ payg/ v1/ request/ chat/ completions PAYMENT-REQUIREDheader and the same JSON body; a quote lasts 120 seconds. Resend the same body with the signed payment, base64 x402 v2, in thePAYMENT-SIGNATUREheader. openapi.json covers this chat route and the package list; recovery is described in the x402 manifest and below.- Answers
- 200 returns
choices,usageandquotum_billingwith the operation id, payment, fulfillment, amount, currency, accounting and the output's expiry. 202 carriesRetry-Afterand 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 409payment_without output.already_ used - 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-Recoverycapability before it sends, together withX-Quotum-Payerand a stableIdempotency-Key, can read the encrypted output for 24 hours:GET https://reads private billing, andquotum. org/ api/ payg/ v1/ request/ operations/ <operationId> /outputafter it returns the saved answer with theX-Quotum-Recoveryheader. 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-Keyfor 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 theX-Quotum-header.Body- Commitment - 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.
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());The same exchange with curl. curl does not sign: PAYMENT is the base64 payment from step 4 above, made by your signer. Send the identical body both times.
BODY='{"model":"deepseek-v4-1-flash-1017","messages":[{"role":"user","content":"say hello in one sentence"}],"max_completion_tokens":1024,"stream":false}'
# 1. the quote: 402, then read the PAYMENT-REQUIRED header
curl -si https://quotum.org/api/payg/v1/request/chat/completions \
-H "Content-Type: application/json" -d "$BODY" \
| grep -i '^payment-required:' | cut -d' ' -f2 | tr -d '\r' | base64 -d
# 2. the paid request, the same body
curl https://quotum.org/api/payg/v1/request/chat/completions \
-H "Content-Type: application/json" \
-H "PAYMENT-SIGNATURE: $PAYMENT" \
-d "$BODY"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_ 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
Diedand 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

