usecompute.dev docs

What usecompute.dev is#

usecompute.dev is a launchpad for coins that buy compute. You launch a coin on a pump.fun bonding curve, paired with whatever you like: SOL, USDC, Bitcoin, Tesla, NVIDIA, the S&P 500, a pre-IPO token. Every trade pays a creator fee, and those fees become the coin's compute budget.

The budget runs real machines that anyone can use from the coin's page: an AI on the model the creator picked, a cloud browser driven by an AI agent that holders watch live, and a GPU that renders images and video. A coin that trades keeps its machines running. A coin nobody trades goes quiet until it trades again.

What fees buy#

The pieces#

Who it's for#

• Communities that want a coin that does something, not just a ticker.
• Builders who want to give an AI, a browser or a GPU a public, self-funding budget.
• Traders who want exposure to the asset they believe in, from SOL to tokenized stocks.
• Anyone curious: using a coin's compute costs nothing and needs no wallet.

The loop#

Nothing has to be switched on by hand. A launched coin starts collecting fees from its first trade, and its machines become available as soon as it has budget. The loop runs every minute: fees are collected, new trades are read from the chain, and every coin with compute gets a running cloud browser.

From trades to dollars#

usecompute.dev reads each trade on the coin's curve straight from Solana and records the creator fee it paid. The sum, valued at the pair's live USD price, is the coin's compute raised. It's an exact total of fees actually paid, not an estimate, and you can check each one in the coin's trade tape.

compute raised  = Σ creator fee (pair asset) × pair USD price
compute spent   = Σ AI replies + browser minutes + GPU renders (USD)
available       = compute raised − compute spent

Metering#

Every AI reply is charged at the model's real token cost. Browser time is charged by the minute while the browser runs. GPU renders are charged a flat price per run. All of it is recorded against the coin and shown on its page, split by kind.

Launch a coin#

1. 1
   Connect a Solana wallet
   Top right. Phantom, Solflare, Backpack and WalletConnect wallets work.
2. 2
   Pick a pair
   SOL, a stablecoin, a major like BTC or ETH, a tokenized stock, a pre-IPO token or a meme.
3. 3
   Set the identity
   Image, name (up to 32 characters) and ticker (up to 10). Permanent once minted.
4. 4
   Set up the compute
   Pick the AI model and, optionally, a persona. The browser and GPU come with every coin.
5. 5
   Pay and sign
   Pay in SOL or in the pair asset, add an optional first buy, approve one wallet prompt.

Use a coin's compute#

1. 1
   Open a coin
   From Explore, sorted by newest, market cap, compute or curve progress.
2. 2
   Pick a console tab
   AI to chat, Browser to give the agent a task, GPU to render an image or video.
3. 3
   Watch it work
   Replies stream in, the browser's live window and step log update every few seconds, renders land in the gallery.

What a pair is#

A coin's pair is the asset its bonding curve is priced in. Buyers pay in it, sellers receive it, and creator fees accrue in it. A coin paired with TSLAx is bought with tokenized Tesla shares, and its compute is funded in Tesla.

What you can pair with#

The list comes live from pump.fun's on-chain whitelist, so it's always exactly what the program accepts. The launch page shows it with logos, categories, a verified mark and USD prices.

Choosing one#

• Pair with what your community already holds; nobody likes swapping just to buy.
• Compute is funded in the pair asset, so its price moves your budget.
• SOL pairs are the cheapest to trade. Some tokens charge a small transfer fee, which the quote already includes.
• Stablecoin pairs give the most predictable budget.

Identity and metadata#

The image and metadata are pinned to IPFS before the transaction is built, so the coin renders everywhere the moment it exists.

AI model and persona#

Pick the coin's AI from every model OpenRouter lists, filtered by lab, price, context length and vision. The persona is a short brief that shapes how it talks: start from a preset (Analyst, Degen oracle, Researcher, Browser pilot, Shitposter) or write your own. The AI always knows its coin's name, ticker and pair.

The first buy#

You can buy into your own curve in the same transaction that creates it. Because it's atomic with creation, nobody can get in ahead of you. The form suggests sizes in dollars ($10, $50, $250) and converts them into the pair asset. Leave it at $0 to launch without buying.

Paying with SOL or the pair#

What you sign#

The server builds the transaction and signs only with the new coin's mint key. You sign as the fee payer. When paying with SOL for a token pair, the swap is confirmed on-chain before the launch is sent. If the launch then fails, you keep the asset the swap bought.

After launch#

• The coin appears on Explore and gets its own page within seconds.
• Its AI answers as soon as the coin has compute, and its browser starts within a minute after that.
• It trades on pump.fun and anywhere that supports pump curves.

The budget#

A coin's compute is one shared pot in dollars. Its AI, its browser and its GPU all draw from it. The coin page shows raised, used, available, spend by kind and how many AI replies are left at the current model's price.

What things cost#

$5.00 of creator fees buys roughly:
  ~1,250 images            (5.00 / 0.004)
  ~83 short videos         (5.00 / 0.06)
  ~41 hours of browser     (5.00 / 0.12)
  thousands of AI replies  (on a small model)

Limits#

Running out#

When available compute drops below $0.05, the coin's browser is shut down, queued browser tasks are closed with “This coin is out of compute”, and new browser and GPU jobs are refused. Nothing is lost: as soon as trading pays more fees, the browser starts again and every console works.

Models#

Every coin has an AI on the model its creator picked: several hundred models from Anthropic, OpenAI, Google, DeepSeek, Qwen, Mistral, xAI, Meta and more, through OpenRouter. The model shows as a tag on the coin's card and page.

What it knows#

• Its coin's name, ticker and pair, and that it runs on usecompute.dev.
• That its compute is paid for by its coin's creator fees.
• The persona its creator wrote, if any.
• Your conversation, up to the last 12 turns. Conversations aren't stored between visits.

Cost#

Each reply is charged at exactly what the model cost, recorded against the coin, and counted in the coin's AI spend.

What it is#

Every coin with compute gets its own real Chrome browser in the cloud, powered by Browserbase. It's started automatically, kept running while the coin has budget, and renewed before it times out. A fresh browser opens on the coin's pump.fun page.

The Browser tab on the coin page shows the live window, view-only, with a LIVE badge. Everyone watching sees the same browser.

Giving it a task#

1. 1
   Write what it should do
   For example: find the top story on Hacker News and summarize it. Up to 500 characters.
2. 2
   It joins the queue
   Tasks run one at a time, oldest first. The tab shows how many are waiting.
3. 3
   Watch it work
   Each step appears as it happens: what the agent did and why, while the live window moves.
4. 4
   Read the result
   When it's done, it writes a short report for holders. Past tasks stay in the history.

How the agent works#

The agent is a fast vision model. Each step it looks at a screenshot of the page, the current URL, your task and what it has done so far, then picks one action:

A task ends when the agent says it's done, or after 14 steps.

Rules#

• It never enters passwords, payment details or personal data.
• It never buys anything.
• The live view is view-only; nobody can type into the browser directly.
• The browser is shared, so don't ask it to do anything private.

What it renders#

Renders run on GPUs from fal.ai. Pick image or video in the GPU tab, describe what you want in up to 500 characters, and hit Render.

How a render runs#

The gallery#

Every coin keeps a public gallery of its latest 24 renders. Pending renders show as rendering and fill in on their own. Outputs are public: anyone visiting the coin sees them.

Trading fees#

Every trade pays a protocol fee to pump.fun and a creator fee that funds the coin's compute, both in the pair asset. Trade on pump.fun or any app that supports pump curves; the Trade button on each coin page links there.

The curve#

A new coin starts on a constant-product curve between virtual reserves of the pair asset and its own supply of 1,000,000,000 tokens. Buying moves the price up; selling moves it down. There's no order book and nothing to bootstrap.

price       = virtual pair reserves / virtual token reserves
market cap  = price × 1,000,000,000
USD         = pair amount × the pair's USD price

Graduation#

When the curve sells out, its liquidity migrates to a PumpSwap pool in the same pair, and trading continues there.

Non-custodial#

usecompute.dev never holds your funds or keys. Transactions are built server-side, signed in your wallet, then broadcast. The only key the server signs a launch with is the new coin's own mint key.

Transaction checks#

• Every transaction must be paid by the wallet that prepared the launch.
• The launch must create exactly the mint that was prepared.
• An optional first transaction must be a Jupiter swap and nothing else.
• First buys are capped at $25,000.

Machines#

• Each coin's browser is an isolated cloud session, never your machine or your sign-ins.
• Only the view-only live link is public; control of the browser stays server-side.
• API keys for AI, browsers and GPUs never leave the server.

Abuse protection#

The AI, browser and GPU endpoints are rate-limited per visitor (and the AI per coin too), prompts are length-capped, and every use is metered against the coin, so no one can spend more than a coin has raised.

All endpoints are JSON over HTTPS on https://usecompute.dev. No key is needed. Amounts ending in Usd are dollars; others are in the pair asset.

Read endpoints#

const { coin } = await fetch("https://usecompute.dev/api/coins/" + mint).then((r) => r.json());
const left = coin.computeRaisedUsd - coin.spentUsd;
console.log(`${coin.symbol}: $${left.toFixed(2)} of compute left`);

Compute endpoints#

const res = await fetch(`/api/agent/${mint}`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ messages: [{ role: "user", content: "gm" }] }),
});
const { reply } = await res.json();

await fetch(`/api/gpu/${mint}`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ kind: "image", prompt: "a server room made of ascii, cinematic" }),
});
// poll GET /api/gpu/:mint until the job's status is "done", then use output_url

Errors#

Errors come back as { error: string }.

• AI replies and browser reports can be wrong, and nothing they say is financial advice.
• Tokenized stocks and pre-IPO tokens depend on their issuers and can trade away from the underlying.
• Compute depends on trading: a coin with no volume stops funding its machines.
• A compute budget isn't a claim on anything. It's spent on machines, not paid to holders.
• Third-party services (pump.fun, Jupiter, OpenRouter, Browserbase, fal.ai) can fail or change.