How it works

A launch here is an ordinary pons v2 token: a bonding curve holding the entire supply, tradeable from the first block, graduating into a Uniswap pool whose liquidity is locked permanently. What is different is what the fee is for.

Every launch is paired with one model from the OpenRouter catalogue. Every trade against that token pays 2% to the platform treasury, and the treasury exists to buy inference. The sum of every fee ever claimed is the compute pool, and anyone who has launched a token can spend it, on any model the platform carries, not only their own.

1. 01LaunchTitle the token, pick the model it backs, pay the launch fee. The whole supply is minted to a bonding curve, and the treasury is set as the fee recipient in the same transaction.
2. 02TradeTwo percent of every trade accrues as a creator fee, in the asset the token trades against. It sits on the launch's own curve until something sweeps it.
3. 03ClaimThe keeper sweeps each curve into the pons fee escrow, then claims the escrow to the treasury and records what was collected and at what ETH price.
4. 04SpendThe claimed total becomes compute. Anyone who has launched a token can talk to any backed model, and each message is billed against the pool.

The model is chosen at creation and recorded with the launch. It is an OpenRouter id such as anthropic/claude-opus-5, and it is checked against the live catalogue before the launch is recorded, so a token cannot claim to be backed by a model that does not exist.

A model becomes usable when a token launches for it, and not before. The catalogue lists several hundred models; the ones you can actually talk to are the ones something funds. That is the point of the pairing rather than an arbitrary restriction: the fees that pay for inference come from launches, so the models on offer are the ones launches back.

Several tokens can back the same model. Nothing stops it, and nothing about it is special, since they both contribute to the same pool.

The creator tax is 2% on every launch and is not a setting. Letting each launch choose would make what a trade contributes depend on which token it happened to be, and would let a launch opt out of funding the thing it is using.

Fees are charged in the asset the token trades against, never in the token itself, so nobody is handed a bill denominated in something they were trying to sell.

Every launch points at the same treasury address as its creator fee recipient, fixed in the launch transaction and unchangeable afterwards. There are no per-token vaults: one address collects everything, because there is one pool to fund.

The treasury is also the keeper's own wallet, and that is not a convenience. pons credits the escrow to whatever address a launch named, and claim() pays out to whoever calls it, so there is no claiming on another address's behalf. So the only wallet that can collect those fees is the one that owns them.

Fees do not arrive on their own. Before graduation a fee sits on the launch's own curve until a sweep moves it into the pons escrow, and the escrow holds it until it is claimed. The keeper is the process that does both: it walks every launch, sweeps what has accrued, then claims the escrow once.

Nothing is swept until it is worth more than the gas to collect it. Below that floor the fees stay where they are, which costs nothing and loses nothing. The same is true of the claim.

On each claim the ETH amount is converted at the spot rate and that rate is written onto the record, because what ETH was worth at claim time is not recoverable afterwards. If no rate can be fetched the claim is still recorded and the credit is left for a later run, rather than being booked at a guessed price.

The pool is a ledger, not a balance. Every credit and every debit is a row, and the balance is their sum. A stored total would be wrong the moment two inference calls settled at once, and could then never be reconciled against its own history.

Amounts are integer micro-USD, meaning millionths of a dollar. Model pricing runs to eight decimal places per token, and floating point addition over thousands of rows does not stay exact.

Rows carry the launch they belong to where there is one, so a token page can say what that launch contributed. That is attribution, not a wall: the balance is read across every row.

Anyone whose wallet has launched a token can talk to any backed model. Not only the model they launched, and not only while their own token is trading.

Access is proven with a signature, not with a claimed address. A wallet address in a request body proves nothing, since anyone can type someone else's, so each request carries a signed message with a timestamp, valid for ten minutes. There is no session: the signature is checked per request, which costs one signature recovery and means nothing has to be stored.

The browser reuses one signature for its lifetime, so a conversation is one wallet prompt rather than one per message.

Every reply is billed from the token counts OpenRouter reports for that call, multiplied by that model's own published price. It is never an estimate and never a flat rate per message.

The result is rounded up to the nearest micro-USD, so a long tail of sub-cent calls cannot add up to free inference. Both token counts are stored on the message and on the ledger row, so a charge can be checked against the catalogue rather than taken on trust.

Conversations are kept server-side and are public, the way a chart is. The model is what the token backs, so what it has been asked is part of that token's record.

Anything you can do in the chat you can do from your own code. Mint a key on the keys page and point an OpenAI client at https://llmtokens.fun/api/v1.

The request and response are OpenAI-shaped and passed through rather than remapped, so an existing client works by changing the base URL and the key. Two response headers report what the call cost and what is left, so a client never needs a second request to find out.

Keys are stored as a SHA-256 hash and never in plaintext, so the key is shown exactly once, when it is minted. A lost key cannot be recovered, so revoke it and mint another. Revoking keeps the row, because the record of what a key spent is the point of per-key accounting.

A launch holds its entire supply on a bonding curve from the moment it is created. The curve will always sell you tokens and always buy them back, and the price is worked out from how much of the supply has been bought so far. You are never waiting for someone else to take the other side.

Large buys move the price more than small ones, so the price paid on a big order is worse than the price quoted. This is the same behaviour as any exchange with limited liquidity.

Every launch opens with a tax on buying that starts near 99% and decays to nothing within five seconds. It exists so that being first is not profitable: a bot that buys the opening block and sells into the people arriving a minute later gives up more than it gains. Selling is never taxed by it, and the launching wallet is exempt.

When the curve sells out, the launch graduates: everything it collected is handed over to seed a Uniswap v4 pool, along with the share of supply that was held back from the start for exactly this purpose. The liquidity is locked permanently.

There is no unlock, no timelock that expires, and no privileged wallet that can reach it, not the creator and not us. That is worth stating plainly, because rug pulls almost always work by the creator removing liquidity. On a graduated token it is not a promise not to: the function does not exist.

Because the reserved share is fixed at creation, every launch on the same settings graduates into a pool of the same size at the same price, whether the curve was bought out by one large purchase or hundreds of small ones.

Everything runs on pons v2 on Robinhood Chain, chain id 4663. Each launch's own curve and token are created per launch and should be resolved from the factory rather than hardcoded.

View the factory on the explorer →

Two parts of the path above are not automated yet, and it is better to say so here than to let someone discover it.

Launch tokens are volatile and can lose all value. Anyone can create a launch with any title, symbol and image, including ones that deliberately imitate an existing project. Titles and symbols are not unique and are not verified.

Transactions are submitted by your own wallet and may be irreversible. Nothing here takes custody of your tokens or your funds.