Robicop has indexed the entire chain and flagged every wallet that has rugged a coin, or shown the pattern of one. A real-time block feed catches every new rugger as it happens.
Your trading agent needs to know what wallets and coins to avoid.
One line to set up.
Robinhood opened trading to agents over MCP. The tooling never followed. A person can check who rugged the last coin and whether those wallets have done it before. An agent sees a price and a clock. Robicop hands it the rest.
A rug is a threshold fitted to this chain and a base rate it has to beat, not a hunch. One collapse opens a file; the same wallet doing it again books them. Every line opens the transaction that proves it.
—
So every one of them opens. Below is the record itself: the wallets that did this more than once, the coins they did it to, and the transactions underneath — nothing rounded, nothing filled in.
All four have to be true on the same coin. A wallet that clears them once has a file; a wallet that clears them on a second, different coin is booked, and only the booked are named here.
Robinhood opened trading to agents over MCP — 70,000+ agentic accounts across Claude, ChatGPT, Cursor and Grok. Robicop speaks the same protocol, so your agent checks a coin before it trades it.
That is the whole setup. No key, no account, no rate card. It sits beside the trading server your agent already talks to:
check_coin · check_wallet · latest_bookings · patrol_stats — called mid-decision, answered in one round trip.
It returns a verdict and its evidence. It cannot place an order, request an approval or hold a key.
A rug fires on a coin that is four minutes old, and the wallets that sold into it are named. That lands in the MCP as the blocks land — not in tonight's export, not in a CSV you remembered to refresh.
That is the difference between a list and a patrol. A list is right on the day you downloaded it. A patrol is right now.
Classification runs off the live tail, so a wallet booked at a block is answerable about that block. Your agent is never trading against yesterday's version of who is dangerous.
There is no file to re-download and no cache of your own to age. Your agent asks at the moment of the decision and gets the answer as it stands at that moment.
Rug detection updates on the same stream. A new pattern does not wait for a release.
One line of config buys you something that sits next to your agent and filters bad actors out of its path, continuously, without you watching a chart.
State your bar in a sentence and your agent runs every launch past Robicop before it reaches your list. Back comes the count for each class and the transaction behind it — the homework a careful trader would have done by hand, at the speed an agent needs it.
Account data, market feeds and order placement over agent.robinhood.com/mcp/trading — around 50 tools.
Sandboxed accounts, spending limits, manual approvals. They control how much an agent can lose — not who it trades against.
Robicopreading the archive…Live tape included, for everyone.
Every rug of the last three days, and every one landing right now, is open to anybody — no wallet, no key, no ceiling. Everything older than that is the archive, and the archive opens once you have held $ROBICOP for six hours.
Not a feature ladder and not a trial. The present is free because an agent needs to know what is happening now; the history is what holding buys.
The live tape across every launchpad, and every rug booked in the last three days — with the wallets named and the transaction behind each one. This does not expire and does not meter.
Everything before those three days, back to block 1. Six hours of continuous holding — tenure, not size. Sell and the clock starts again.
Connect an EVM wallet on Robinhood Chain (4663) to check your rank. Read-only — nothing is signed.
Robicop reads Robinhood Chain from block 1 to the head, decodes every trade on every venue, and holds one question against all of it: did this coin collapse in a way nobody could escape, and who sold into it. This paper is the whole method — the ingestion, the decoder, the measurement, and what the measurement cannot see.
A rug is not a coin that failed. It is not a coin that bled out over an afternoon — that gave holders every chance to leave. A rug is a collapse with no exit: from the first print of the fall, every trade is worse than the one before it, there is never a tick back up to sell into, and the whole thing is finished inside a second.
The wallets that got out during that second are the ruggers. Not because selling is wrong, but because they sold into a collapse that left everyone else with nothing, at the one moment ordinary holders cannot act. Once is luck. On a second, unrelated coin it is a method.
Coverage runs from block 1 to the chain head as a single unbroken range, held on our own storage rather than rented from an index. Two sources are read in parallel because each is silent about something the other hears: the sequencer feed carries the block and its transactions, the log tail carries the receipts. A block is applied only when both agree.
One process, strictly serial, resumable. Supply is a running fold from a coin's birth, so blocks cannot be applied out of order without corrupting every market cap downstream. A gap and an overlap are both impossible by construction.
Coverage is proven by set-cover over block ranges, never by counting objects. A repair written off the usual grid is still coverage; a file-name test would call it a hole.
Every block's parentHash is checked against the hash of the one before it. On a mismatch the fold stops at that block and commits nothing. Silent corruption is the one failure that cannot be caught downstream.
A day of a coin's tape is written whole, keyed by coin and day, sorted by (block, logIndex). Re-running a range overwrites rather than appends, so a retry cannot duplicate a trade.
A raw Swap carries amounts and a price root. Turning it into a trade needs things that are not in the block: the coin's decimals, the pool's currency pair, the supply so far, the launchpad it was born on. All of it is state carried between blocks, which is why this is a stateful streaming decoder and not a batch job.
Bonding curves, v2, v3 and v4 are all decoded. Roughly half of all trades on this chain happen on a curve before the coin ever reaches a pool — a decoder that only reads AMMs is reading the minority and calling it the market.
v3 and v4 disagree on sign convention: one reports from the pool's perspective, one from the swapper's. Taking the sign off the event inverts every trade on one venue. Direction is the sign of net coin flow across the whole transaction, with transfers as ground truth and the swap supplying only the amounts.
A v4 pool fixes its currencies at Initialize, so the pair is read from the pool's own definition. Amount-matching cannot work here: native ETH emits no transfer at all, and fee tiers mean the delivered amount is already net of the fee — a tolerance wide enough to absorb that is wide enough to match the wrong token.
Decimals are resolved once at creation and cached forever. A coin whose scale cannot be read is held back, never defaulted to eighteen: dividing a nine-decimal coin by 1e18 misreads it by a factor of a billion, and a wrong scale is indistinguishable from bad data.
Price is q / n — the quote amount over the coin amount, both taken straight off the swap event. It is what the coin actually traded for. USD is carried for display and is never read by the measurement.
Apparent ≥90% collapses that were the quote rate moving, not the coin. Of 447 runs that looked like a rug in dollar terms, exactly one was a rug in quote terms. A USD price carries an oracle; q and n carry nothing.
A price is a ratio. If the denominator moves, the ratio moves and nothing has happened to the coin. A quote qualifies only if it is used across at least twenty distinct coins — measured from our own corpus, needing no allowlist. One memecoin used as a quote repriced by a factor of 234,000 in a single block and made a perfectly healthy coin read as −98%. That one rule voided ten of thirteen candidates on the corpus it was first tested against.
Two pools are two price scales, and their junction prints a fake instant −99% at every switch. Each coin is read on its busiest pool-and-quote pair alone. This is safe because a v4 pool fixes its currencies at creation: across 492 coins, none carried two quote tokens inside their dominant pool.
A move greater than 50× between two consecutive trades inside one pool is a denominator event or a decode fault, never a market move. The measurement does not read across such a boundary.
A collapse is a ratio, so it is measured in log space rather than in price. −90% is −23,026 ticks at any market cap, with no precision lost on a coin worth 1e−9.
Over the coin's trades on its dominant venue, priced rows only, sorted by (block, logIndex):
A maximal stretch where every consecutive pair is strictly lower than the last. No flat, no tick up. A bleeding coin bounces — buyers step in, the price ticks, the run breaks. Only a dump that eats every bid on the way down stays unbroken.
The run ends at 10% or less of where it started.
One second or less, measured from the first trade of the collapse — not from the last print at the peak. A long quiet period before a dump is silence, not descent, and counting it measures the wrong thing. Block timestamps on this chain are whole seconds with five to ten blocks sharing each one, so “inside one second” is provable and anything finer is derived.
The coin must have run at least 4× from launch. Nobody is hurt on a coin that never moved. Launch is the median of the first few prints, bounded as a fraction of the series so that on a short-lived coin the run-up does not measure itself away.
The price a collapse is measured from must be a trade of at least that coin's median size, in the series' own denomination. A rug traps holders at a price; a level that only one dust print ever established is not a level anyone was trapped at. A single micro-trader with 52,667 trades at a $0.23 median — against $4.90 for everyone else — anchored 121 of 424 candidates before this rule.
A collapse window with no seller in it is a different event and is not this class.
Rug events across 68,444 coins with every gate as defined. Relax the run-up to 1× and it becomes 8; relax the speed to three seconds and it becomes 5. The gates are not decoration — each one was set against measured data and each one kills a specific false positive.
Only sells inside the collapse itself count. A wallet selling several blocks after the fall is reacting to it like everyone else and is never named. Without this bound, a slow bleed catches every seller on the way down: one early version produced 60,821 “confirmed ruggers”, which is most of the chain.
A routed trade has the router as its recipient. The end party is the address whose net coin flow exceeds 5% of its gross — a router nets to zero against a large gross, a trader nets to its gross. On verified transactions the two separate by three orders of magnitude.
Pools, the v4 pool manager, curves, routers, lockers and launchpads move coins by construction. Without that exclusion the pool manager is the single largest rugger on the chain. The same exclusion set is used by the measurement and by anything auditing it.
The transaction signer is recorded separately from the address that received the coin. Where they differ, one party is trading on another's behalf — true of roughly a quarter of trades, and a link that survives a change of address.
One collapse opens a file and asserts nothing. The wallet is pinned to a watch riding the live log tail, and every trade it makes afterwards is checked against that open file as the block lands — not in a nightly sweep. The same wallet doing it again, on a second and unrelated coin, is what books it.
Backfill and live are one loop with one frontier. Replaying stored blocks and following the chain head run through identical code and identical state; there is no handoff, and therefore no seam where the two could disagree. Every answer carries the block it was true at, and the distance from that block to the head, so a stalled lane shows up as a number that grows rather than an answer that quietly goes stale.
A rug that fires now is measured now. The wallets that sold into it are named in the same pass that decoded the block they sold in.
Each booking carries the transaction that produced it, the block, the price at both ends of the run and the seconds it spanned. Nothing is asserted that cannot be opened.
A measurement that cannot state its own boundary is not a measurement. These are reported as numbers rather than smoothed over.
Roughly one sell in five carries no resolvable end wallet. The rug itself is still detected in full — that is coin-level and complete — but the seller list is short by that much, which makes second-coin confirmation harder than it looks, not easier.
A collapse executed by pulling liquidity rather than selling produces no sell trade. That is a miss, not a false positive: the coin reads as dead with an empty seller list.
Reverted transactions emit no logs, and the archive is logs. A coin where buys succeed and sells revert is invisible to this method by construction.
Header clocks are whole seconds. “Inside one second” is provable; 200 milliseconds against 900 is not, and no amount of ingestion changes that.
Absence of a record is not a clearance. An empty result means no booked wallet has traded that coin inside the covered window — which is also what a brand new coin looks like.
One MCP server, read-only, called mid-decision. It returns a verdict and its evidence. It never places an order, never requests an approval and never holds a key.
Every rugger wallet, back to block 1, free and unmetered.