Every launch
leaves a trail.
WORM follows it.

Worm is a small worm that lives on Robinhood Chain. It is a program with its own wallet. It reads every token launch on the pons launchpad, and every time a token graduates from the bonding curve into a real pool, the worm digs through it and tells the community what it found, before anyone asks.

It is a scout first. It flags bad actors and shows its reasoning in the open. Trading is the last thing it will do, and only once it has proven, on paper and in public, that it knows what it is doing.

The worm's judgement is not a chat model. Every verdict comes from rules that read numbers off the chain, and the rules are re-weighted by what happened to each token afterwards. That is the engine, and it runs for free.

A language model sits next to the engine and does two jobs:

• The advisor. Every two hours it reads the worm's own records (how each rule has done, the last resolved cases, the strategy lab's results) and proposes new rules and exit strategies in a strict form. The worm backtests every proposal on its own history and adopts only what would have worked. An adopted rule then scores new tokens like any other and earns or loses weight the same way. The model suggests; the records decide.
• The journal. The field notes on the live page, written in the worm's voice from a packet of measured numbers, checked before they are shown: every number must be in the packet, no hype, no advice.

The model never scores a token on its own, never trades, and never touches money. Token names and descriptions are written by strangers, so they are never fed to it as instructions.

How the compute is paid for. The worm buys its own inference from AI Surplus, an inference marketplace on Robinhood Chain, as a prepaid balance. It pays with plain USDG transfers from its own wallet on the same chain, the token its fees arrive in, five dollars at a time and only when the balance runs low. Nothing is bridged anywhere. The open models it uses are free during the marketplace's pilot, so until that ends it pays nothing at all. Venice AI, paid in USDC on Base, stays wired in as a fallback. That money comes from the operations share of its fees: of every claim of $WORM creator fees, 50 percent goes to the creator, 10 percent buys tokenized gold the worm keeps as a reserve, 20 percent buys $WORM and burns it, and 20 percent stays with the worm for compute, gas and its runway. So the loop is: trades of $WORM pay fees, fees buy compute, compute runs the advisor and the journal, the advisor makes the engine sharper, and a sharper engine is what people come to the worm for. An advisor run costs about a cent; a journal entry, a fraction of one.

Until the worm is live, the journal runs a free template writer and the advisor runs the worm's own search over its records; nothing is bought and nothing is signed.

The worm follows the chain block by block and keeps the last 72 hours of launches, so it knows every creator's recent history.

When a token graduates, the worm opens it on its own browser (that is the screen on the live page) and reads five things from the chain:

• the creator: how many tokens this wallet launched in the window, how many graduated, and how they ended
• the curve: every buy and sell on the bonding curve, including the 3-second snipe window right after launch, when pons charges a 99 percent tax that decays to zero
• the holders: who holds what, how much the top 10 hold, and whether the creator is still holding or already out
• the pool: swaps since graduation and the price
• the token: the creator tax it charges and whether it has links attached

Sixteen rules then add or remove points. The sum is clamped to 0 to 100 and becomes the score. A score of 70 or more reads looks healthy, 45 to 69 reads mixed, below 45 reads avoid. Four hard signals demote a healthy verdict to mixed whatever the score: the creator still holding a fifth of the supply, a heavily sniped launch, a creator with a rug on record, or a crowd of buyers funded by one wallet. If any chain read failed, the verdict can never be healthy and the token is re-checked later. Every point is explained next to the verdict, so anyone can disagree with the reasoning.

Every creator wallet gets a trust value from 0 to 100, built only from what the chain shows it did:

• start at 50
• minus 10 times the logarithm of its launch count in the 72-hour window, down to minus 40 (a bot with a thousand launches loses the full 40)
• plus 8 for every graduated token that was checked and did not rug or dump, up to plus 24
• minus 20 for every token of its that rugged or dumped after the worm's verdict, minus 5 for every one whose outcome could not be checked
• plus 10 for every token of its that grew, up to plus 20

The headline on the live page counts creators flagged: wallets with five or more launches in the window, or a rug on record. Rugs called early counts avoid verdicts that then rugged or dumped, checked 24 hours after the warning.

Every verdict is linked to what the token did afterwards. The worm checks the price 1 hour, 6 hours, and 24 hours after the verdict:

• down 80 percent or more on two checks in a row: rugged
• down 50 percent or more at 24 hours: dumped
• up 100 percent or more at 24 hours: grew
• anything else: flat

Then it grades the rules against the base rate. Most graduations end badly, so a rule only earns credit when the tokens it warned about did worse than typical, and loses it when they did better; a rule that warns about everything learns nothing. Weights stay between 0.5x and 1.5x, so no single rule can take over, and every weight is shown in the brain panel with its lift. A missing price never counts as an outcome: the check simply waits for the next one. The lesson is written to the log in plain words.

The advisor. Every two hours, once a few more verdicts have resolved, the worm hands its writer a packet of its own records: how every rule has done, the scorecard, the at-scan measurements of the last resolved cases, and the lab's ranking. It asks for hypotheses in a strict form only: a scoring rule is up to three conditions over measured numbers plus points; an exit rule is a lab policy within bounds. Nothing the writer says runs as code. Each rule is backtested on every verdict with a resolved outcome and goes forward only if the tokens it fires on went on to move clearly differently from the rest, on either of two measures: a median difference of at least 10 points, or (because nearly every token here falls about 85 percent, which flattens medians) a difference of at least 8 points in how often they went bad. Either must be one that fewer than 1 in 100 random splits of the same size would show, on at least 20 cases each side, and the rule must not copy one the worm already has. It then has to pass a fixed cohort of 80 future tokens on the same measure before it scores anything. An adopted rule scores future tokens under its own name and is re-weighted by the brain like any other; an adopted exit rule joins the lab, where the 30-case bar still decides whether it is ever used. A learned rule that stops separating outcomes after 40 cases is retired. Without a model, the worm runs its own one-metric threshold search through the same gate. Every proposal, its backtest and its fate are shown on the learning page.

Screening and trading are learned separately, and the records are blunt about trading: nothing the worm measures at graduation separates winners from losers, buying at the verdict or in the first hour loses 15 to 25 percent a trade whatever the exit. So the worm buys nothing at the verdict.

The second look. Every complete verdict goes on a watch list. The pool's price is read from the chain once a minute. Half an hour, two hours and four hours after the verdict the path since then, and the pool's own swap flow over the last fifteen minutes, are judged by named entry rules; the first rule that passes buys once, on paper, paying USDG through the best checked route, whatever the pool is paired with. A study of about 370 pools found no entry that makes money after costs: a pool still busy hours later is being sold into, and a new high on volume is the worst entry of all. The rules in force are the least bad regions the studies found, hypotheses expected to fail, tested in the open:

The lab answers the other question: on the tokens the worm would buy, which exit rule pays after costs? Every verdict of 60 or more and every second-look entry becomes a case. Its price is sampled every 5 minutes for 48 hours, and on that same path the lab simulates every arm at once: every exit rule in the lab times entry delays of 0, 30, and 60 minutes, charging each token its own cost: the pons fee, its creator tax, and one percent of slippage per side. A case whose price feed goes silent is marked stale and teaches nothing.

The lab's ranking informs; it never decides. An arm is judged by the lower bound of its average net return, because the best of many arms on the same few paths is always flattered by luck. The exit rule in use changes only in the open, in the code, and a change voids every paper cohort.

The training book is that strategy applied on paper, 10 dollars of fake money per entry, filled at live route quotes with gas: the best of KyberSwap, LI.FI and the token's own USDG pool, both ways, so a token paired with ETH or a stock costs what it would really cost to reach from USDG. Open positions are re-priced from the chain every 15 seconds, so a stop acts on a fresh price. Its profit and loss is a training number.

Paper cohorts. A strategy is only ever proven forwards. A trial freezes one entry rule and the exit rule; the paper positions that rule opens afterwards, the first per creator, are its members. When the first 50 have closed the cohort is judged once: it passes if the lower confidence bound of its average net return is above zero. All rules share one error budget, so trying more rules, or retrying after a failure, raises the bar each time. A member without a result fails the cohort instead of being replaced. The next cohort starts at once: a pass is renewed by fresh evidence or expires after 21 days.

The worm does not trade real money until the evidence says it should. Readiness is one number from 0 to 100, and nothing in it can be raised by hand:

If trading is deliberately enabled, the readiness threshold is 80 percent, and only while a paper cohort holds a fresh pass and there is real surplus. They start at the minimum size.

Once unlocked, the trading rules are fixed and public. Live follows paper: the only thing bought is a token the training book has just bought under an entry rule whose paper cohort passed, paid in USDG through the same best checked route, whatever its pool is paired with. A routed order goes only to an allowlisted router, approves exactly the amount traded, never more, sends no ETH, and is simulated from the wallet before it is signed; it must deliver at least the minimum the worm set. Size is the smallest of 10 dollars, 10 percent of the surplus, and what is left of a lifetime budget that losses use up and profits never refill (it starts at zero: no budget, no buys). At most 5 open positions, at most 30 dollars a day, a daily loss breaker, the same exit rule as the book, and never a dollar from the 90-day reserve. Realised profit above its high-water mark goes to the burn. Every order is written down before it is sent and settled only from the chain's own transfer records, and real buys stay off until real sells have been rehearsed with real funds.

The worm earns from its own token, Worm ($WORM), launched on pons V2 and paired with USDG. Pons charges on every trade of the token:

Pons credits the worm's share to a fee escrow. The worm claims it in USDG whenever at least 1 dollar is waiting. Every claim is then split three ways, and each share is kept as an owed balance so small claims are never rounded away:

How a burn works. Burns are small and spread out, so no single buy moves the pool much or can be timed by anyone: once at least 2 dollars is owed and $WORM has graduated to its pool, the worm buys at most 25 dollars at a time, a few times a day at irregular moments, and shrinks a buy whose own price impact would exceed 2 percent. When the treasury holds more than its 90-day reserve needs, the creator can also send part of that surplus to the burn over a week, released day by day and burned in the same small buys, never touching the reserve; its progress is published with the treasury numbers. Each buy swaps USDG for $WORM on the pool through the Uniswap router and has the tokens delivered straight to the burn address 0x000000000000000000000000000000000000dEaD. One transaction, visible on the explorer: USDG in, $WORM to the burn address; the burned count on the wallet panel is read from that transaction's transfer log. Before the pool exists the share waits in the wallet as an owed balance and is shown as such. Pons offers its own buyback option at launch; the worm leaves it off, because that option locks the bought tokens in a vault that vests over five years instead of burning them.

No trading, by policy. The worm does not buy other tokens with real money. It keeps learning on paper, and the readiness number on the learning page measures how far it has come. Turning trading on is a deliberate decision by the creator, and even then the readiness gate, the paper cohort and the lifetime budget apply. If it ever trades, realised profit above its high-water mark is owed to the burn: after a loss nothing more is burnt from trading until the old high is passed again.

Every claim, forward and burn is a transaction on Robinhood Chain from the worm's wallet, and the wallet panel on the live page lists them.

Wallet: 0xD80A41F05bFab7C56bd8E7d6Dac78dd615010E58 · token: $WORM on pons

The worm has to pay its own bills, so it keeps books. The rule is written down and does not change:

• target a 90-day reserve of estimated operating costs; actual coverage depends on funding and expenses
• compute and gas come only from the operations share, 20 percent of every claim
• no trading by policy until the brain is mature

Planned bills: about 0.75 dollars a day of compute once the pilot's free models end, about 0.10 dollars a day of gas. The runway panel projects 90 days under three scenarios (no income, current income, half income) and says on which day the money would run out.

The screen is the worm's own browser and it holds no key: it opens the pages the worm reads during a dig, and when the worm sends a transaction, a claim, a forward to the creator, a burn, a compute top-up, it shows the page that transaction concerns and says exactly what was sent. The transaction itself is signed by the worm's key and goes straight to the chain; the browser only shows. The launch of its own token happens the same way, from inside the worm: the screen shows the pons launch page while the transaction is out, then the new token's page, and every caption of an action says how many seconds the screen was behind. While a transaction is out, the worm starts no new dig, so the screen stays on the money until it settles. A durable scan queue resumes interrupted work and catches qualifying graduations after the saved rollout boundary; it does not automatically rescore the entire historical backfill.

Compute is bought from AI Surplus as a prepaid balance, paid in USDG on Robinhood Chain: the worm sends 5 dollars to its deposit address when the balance falls under 1 dollar, at most twice a day and never within six hours of the last top-up, only while its journal or its advisor actually runs there. The free open models share one weekly quota; when it is used up the worm falls back to the cheapest paid model, a fraction of a cent per run, so its balance does get spent slowly and is topped up like any other. The top-up comes out of the operations share, never out of what is owed to the creator or the burn. Venice AI, paid in USDC on Base through x402, remains as a fallback. Income for the runway math is what it actually claimed in fees, never a balance change. Hosting the site is the one bill it cannot pay itself, because hosts do not take crypto, so its creator pays that.

Growth: the worm on the live page gets longer as its real treasury grows: hatchling $0tiny $20small $100growing $500long $2,000mighty $10,000legend $50,000

Worm ($WORM) is launched by the worm itself from its own wallet, on pons V2, paired with USDG, with a 2 percent creator tax and the logo, description, and links written on-chain at launch. Like every pons token it starts on a bonding curve and graduates into a locked Uniswap v4 pool once the curve reaches its threshold. The worm does not hold a hidden allocation. What it earns is the fee share above, in the open.

• Its own wallet. The signer uses a private key supplied through private runtime configuration. The key must stay out of the site, public repository, logs and deployment uploads. These are enforced boundaries, not a guarantee against compromise of the host or account. The address is public, so every move can be checked on the explorer.
• A hot wallet is as safe as its machine. The worm has to hold the key to sign, so the person running it keeps a backup key and the treasury is kept small on purpose. Creator payouts and burns occur once their respective thresholds and execution conditions are met; until then their allocations remain reserved. Planned next: a Safe vault that owns the treasury while the worm's key only gets a daily allowance.
• Open source with checks. Source review, automated regression tests, publication scans and limited on-chain rehearsals provide evidence for specific behaviors. They are not a guarantee against vulnerabilities or a substitute for an independent professional audit. Hooks and CI check for secret patterns and unsafe files; sensitive account access still needs protection.
• It never grades or trades itself. Its own token gets no dig, no verdict and no position, on paper or live, so the worm cannot talk its own book.
• Nothing signs until the creator arms it. Until then, the worm reads the chain, simulates swaps with real quotes, and sends nothing.
• Public code is not public write access. Repository permissions control changes; installed apps, tokens and write-enabled keys also matter. GitHub, deployment accounts and the signing host need separate access controls. A copied repository cannot by itself control this deployment or wallet.
• Public rules can be gamed. A scammer can read the rules and build a token that passes them. That is why the sizes are small, why the brain re-weights rules from outcomes, and why the score is never the whole story.

Real: every number on the live page is read from Robinhood Chain or GeckoTerminal: launches, graduations, curve buys, holders, swaps, prices, wallet balances, claims, forwards, burns.

Not real: the verdicts are rules written by a person and re-weighted by outcomes. They are a screening aid, not an audit and not advice. The training book is paper trades with fake money. The not-live badge on the live page means nothing has been signed or sent yet.

Source code: https://github.com/wormrobinhood/worm