how a seat works.

1 · the seat

a seat is one wallet holding 0.01% of the supply of $QUOTUM in the staking contract. there are a hundred seats, one per wallet. the next wallet waits in a queue that the contract keeps and the page reads from the chain.

• stake any amount at any time. the moment your stake crosses 0.01% of the supply you take the first free seat, or join the tail of the queue if all hundred are taken.
• unstake at any time, mid-session included. if your stake falls under 0.01% the seat frees, its key is deleted, and the head of the queue takes the seat. unstake returns the stake and nothing else.
• idle: two sessions in a row with zero spend and, if someone waits, the seat goes to the queue. the stake is not touched; you are moved to the tail and the next wallet is seated.

the staking contract has no owner, no pause and no withdraw path. the keeper can only mark idle seats and release them after two idle sessions, and only when someone waits in the queue.

2 · the session

the chain runs all day. the market the coin is priced against does not: nvda trades its session 13:30 to 20:00 utc on nyse trading days. so the session is a state, not a switch. the key never turns off.

the cap is set at the open and counted at the bell. one session, one bell, one burn.

3 · the cap

the cap per seat is the smallest of three numbers, computed at 13:30 utc by the sink from what the chain shows:

in words: a seat can spend at most fifty dollars a session; never more than its share of the tax actually collected in the last day; and never more than the seat itself is worth. with no seat taken at the open the tax is shared as if by one. the tax is the 1% creator tax of the $QUOTUM / NVDA pair on Pons, collected in nvda. the page prints the tax, the seats and the resulting cap every minute. if the tax dies the cap prints $0 and the page says so.

after the bell the same number is halved, at the weekend quartered. usd is the provider's dollar of inference, never a share price.

4 · the bell and the burn

at 20:00 utc the keeper first writes the check of every seat's key on chain with report(): spent, and not spent. then it rings bell(). the sink adds up not spent = cap − spent over every live seat and:

• the nvda behind it buys $QUOTUM on the pair in one trade and burns it with the token's own burn(). the supply drops by exactly the tokens in the Burned event, with the dollars, the nvda and the average price beside them.
• the buy takes the pair's price, and refuses one more than 10% plus the pair's fees over the higher of the session's and the last hour's time-weighted average: a spot pushed at 19:59 moves neither.
• it buys only with the nvda the tax has paid into the sink, after what is owed to the provider. what has no nvda behind it, a leftover under one dollar, or a refused buy is emitted as Died with the reason; the nvda of a refused buy stays for the next bell.

plate ii · the bellthe keys go up in smoke

no seat receives a token. the seat keeps its key; the leftover of every seat goes to the burn. nothing is minted, the supply only goes down.

spent cap is different money: the nvda behind it is owed to the inference provider, forwarded by forward() to one published payment address, and paid with a receipt.

5 · the key

one key per seat, bound to the seat's wallet. no key exists before the seat's lock is an event on chain (SeatTaken); then the keeper issues a venice key in private-only mode, sign a message from the seat wallet on the seat page to receive it. the key's limit is the seat's cap for the session. when the seat is freed the key is deleted. any openai-compatible client works.

# the base url is posted with the keys at launch
from openai import OpenAI
client = OpenAI(base_url="posted at launch", api_key="your seat key")
r = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "..."}],
)
# receipt: tokens in, dollars out. nothing else is kept.

every model behind a seat runs in venice's private mode: zero data retention, contract-enforced. venice keeps the key id, timestamps, model and token counts for billing; no prompt or response is stored. the model list with prices is on the home page. when the cap is spent the key answers 402 until the next open.

6 · receipts

two things are not on the chain and are stated as such: the spend per seat, and the payment to the provider.

• spend per seat comes from the provider's usage api. the keeper writes it with report() as Reported(session, seat, usd, receiptHash). the receipt file for a session is at /api/receipts?session=N, one row per seat; hash is keccak256 of the row's json without its hash field. hash the row again and compare with the event.
• payments: the tax lands in a contract with no withdraw path. it forwards what is owed to one published payment address, which converts and pays the provider. every payment is posted on the home page with its tx.

the keeper is one process with its own key. it can open a session, report spend, ring the bell, forward what is owed and release idle seats. it cannot move a stake or send nvda anywhere but the payment address and the pair. its state is public at /api/receipts?state=1.

7 · contracts

Robinhood Chain, chain id 4663. all three are immutable, have no owner and no admin withdraw of any asset. sources are verified on Sourcify in english.

events the page reads

• Open(session, capUsd, tax24hUsd, liveSeats) at 13:30 utc
• 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

the observer builds its own time-weighted price from spot samples; anyone can poke() once per block, and more samples make the average harder to move, not easier. if fewer than twelve samples cover the session the bell buys nothing and the leftover dies with the reason.

8 · faq

this is orbio.

a cap per session, not a leftover you list. orbio sells the leftover in a book. here the leftover buys the coin and burns it. no book, no second coin.

the cap is fake, you will stop topping up.

the tax recipient is a contract with no withdraw path. it forwards to one published payment address, every payment is posted with its tx, and the cap is a formula on this page. if the tax dies the cap prints $0 and the page says so.

private is marketing.

private is a property of the model list, not the pitch. every model behind a seat is the provider's private mode, zero data retention, contract-enforced. the receipt is tokens in and dollars out.

faucet.

a faucet gives it away. a seat costs 0.01% of the supply and the cap is whatever the tax collected, at most $50. the key goes with the stake.

farming, circular, vamp.

one coin, one pair, one tax. nothing is minted, nothing is paid out. the tax buys inference, and what the seats did not spend buys the coin and burns it. that is the whole loop.

dividend, yield.

nothing is paid out. the seat gets a cap it can spend, and no token; what it does not spend is burned. unstake returns the stake and nothing else. capacity, not yield.

rug?

the staking contract has no owner and no withdraw. the sink has no owner and no withdraw. unstake works at any time. what can go to zero is the coin, not the stake.

lock?

the launch share is burned, tx in the launch thread, and every bell burns more. the seats lock 0.01% each, by choice, and can leave any time.

where does the tax go?

into a contract. spent cap is forwarded to the payment address and buys inference. unspent cap buys $QUOTUM at the bell and burns it. both are events on the home page.

why the nyse bell, robinhood is 24/7.

the chain is 24/7. nvda is not: its session is 13:30 to 20:00 utc. after that the cap is half, at the weekend a quarter, the key never turns off. the session is a state, not a switch.

how big is a seat?

0.01% of the supply in the staking contract. a hundred seats. the next wallet waits in a queue that reads from the chain.

what if nobody spends?

then the whole cap, as far as the tax paid for it, buys the coin and burns it. nothing goes to the provider that session. the page shows it.

pair?

nvda on pons. the tax lands in nvda. the cap is quoted in dollars of the provider, never in shares.

demo?

the key works from any openai-compatible client. the snippet is above. the receipt shows tokens in, dollars out.

clone of aria, of venice?

we are a customer of the private mode, not a fork of a token. no bond, no second unit, no mint rate. the cap comes from the tax of one pair and is counted at the nyse bell.

back to the seats