8 tools. One chain.
Every field explained.
Keelage is an MCP server, the standard way an agent connects to a tool: 7 tools everywhere, and keelage_pay on the hosted server. Your agent connects once, lists the tools, and calls them with a contract address. Every answer is JSON with fixed keys. Unknown is null, never zero.
Local or hosted. Same code.
The local server runs on your machine with Node 22 or newer, reads public APIs, and needs no key. The hosted server at mcp.keelage.ai runs the same package behind a free quota, with prepaid USDG credit (a dollar stablecoin on the chain) past it. Every tool is read-only and idempotent. A scan takes 10 to 40 seconds because it reads 4 upstreams in sequence and paces itself under their limits.
{ "mcpServers": { "keelage": { "command": "npx", "args": ["-y", "@keelage/mcp"] } } }
claude mcp add keelage -- npx -y @keelage/mcp
codex mcp add keelage -- npx -y @keelage/mcp
npx -y @keelage/mcp scan 0xf0e17e54239cd945cd7bea471a3a2ca6a8c7f7a3 --text npx -y @keelage/mcp holders 0x… npx -y @keelage/mcp template 0x… npx -y @keelage/mcp record
Optional environment: ROBINHOOD_RPC_URL (defaults to the public RPC), KEELAGE_STATE_DIR (cache, defaults to ~/.cache/keelage), TYPESAFE_API_KEY and SOCIALDATA_API_KEY for the optional context lines. Nothing in the server can hold a key that spends.
What you can ask, and what comes back.
keelage_scan
Input: address, optional ruleset, and on the hosted server wallet. One token at the 3 checks.
| Key | What it holds |
|---|---|
| verdict | moments is the answer: code (clean code, not clean, unread, with the reasons and caps), activity (passes, fails, not judged, with the reasons, caps and tier) and size (sized with the dollars, share and pool, or not sized with the one reason). head and why say the same in one line each. key keeps the 0.3 word (ELIGIBLE, NOT_ELIGIBLE, FAIL, UNVERIFIED) and keys maps each to its moments. ruleset names the policy. |
| tier · actionable · entryBlock · score | How spread out the holders are (the tier), from the 10 largest wallets' share; whether the price was not up more than 30% today with real trades going through; the one reason it wasn't; the ranking score (ranks, never admits). |
| size | usd when eligible: the tier's share of the pool (1% when spread out, the conviction tier; 0.5% when middling, the scout tiers; the dollar caps came out 2026-10-06). A spread-out token with any unknown takes the middling share, and cappedBy names the unknown. |
| market | Price, liquidity, market cap, 24h volume, buys and sells, 24h change, age in days, the pair and dex, the quote symbol. |
| location | Percent below ATH, percent above the 30-day low, the base band in words, ATH and low values, median daily range over 14 days. |
| structure | Pass or fail with reasons (what blocked) and caps (what's unknown). Verified source, contract and implementation names, proxy type, creator, template key and verdict, privileges found in the ABI, whether owner() is renounced, transfer-tax identifier counts, sells clearing, liquidity drawdown. |
| holders | Count, top-10 share excluding pools and contracts (with its source), top-10 including pools, largest wallet, contracts and pools among the top 10, creator share. |
| goplus | Corroboration only: honeypot flag, buy and sell tax, mintable, pausable, LP mode and LP holder statistics. record:false when GoPlus has nothing. |
| takeoverClaim · discoveryShape · jev | A paid takeover claim if present (a caution). Whether the token sits inside what our hourly read covers. The optional probability context line. A scan doesn't read X; that's keelage_x, its own call. |
| links · scannedAt · disclaimer | DexScreener, GeckoTerminal and Blockscout pages. The timestamp. "Research only, not financial advice." |
keelage_holders
Input: address, optional smartAccounts (default true). The holder map.
| Key | What it holds |
|---|---|
| holderCount · totalSupply | From the explorer. |
| top10 | Share excluding pools and contracts, share including pools, largest wallet, how many contracts and pools sit in the top 10. |
| burnPct | Share held by the zero, dead and 0x1 addresses. |
| smartAccounts | How many of the listed wallets are EIP-7702 delegated accounts (how the Robinhood app wallet reads), and their combined share. |
| holders | Up to 20 rows: address, percent of supply, balance, is it a contract, is it a pool, is it a burn address, the explorer's name for it, smart-account flag. |
| poolsKnown · creator · creatorPct | Every pool address we matched, and the deployer with its current share where GoPlus has it. |
keelage_template
Input: address. Which launcher factory the contract came from.
| Key | What it holds |
|---|---|
| template | Key (one of the launcher templates the landscape counts, or unregistered), verdict, what it matched on, the fee model, and the census note. |
| contract | Verified source and when, compiler, contract and implementation names, proxy type, creator, function count. |
| privileges · livePrivilege · taxCode | Owner privileges in the ABI; whether any can change what holders can do; tax and reflection identifier counts and whether they count against the token. |
keelage_x
Input: address, optional fresh (skip the 6-hour cache). What X is saying about the token in the last 24 hours. Context only: it never moves a verdict, which is why it's a separate call.
| Key | What it holds |
|---|---|
| query · queryMode | What we searched: the cashtag for an ASCII symbol, the name plus "robinhood" for one X won't index as a cashtag. |
| posts24 · accounts24 · views24 · likes24 · replies24 | Counts over the 24-hour window. Reposts are counted separately in rts24. |
| copyPasteShare · tone | The share of posts that repeat one template, and what that implies: organic, campaign, or mixed. |
| accountsBig · bigAccounts · medianFollowers | How many posting accounts have 10,000 or more followers, who they are, and whether their post meant this chain's token or one with the same ticker elsewhere. |
| chainMentions · otherChainMentions | Posts that name Robinhood Chain, and posts that name another chain. A ticker is not a token. |
| meta · big · line | A one-line model-written read of what the posts are pushing, the one line on the large accounts, and the card line as plain text. |
| at · cacheHours · sources | When we read X, how long we keep it, and which source answered each half. Unknown halves are null. |
keelage_record
Input: optional table, history. With no input you get the rules with their origins plus live: recomputed every night: every passed token against its 24-hour, 7-day and 30-day outcome, and every token, every day since each token’s first pool. No dated studies. table picks one live table: horizon · band · tier · mcap · pool · age · dayOne · claim · jev · xPosts · xTone · kind · repeat · launcher · projectType · regime · sized · holderGrowth · path · derived · lines · tokenDays · universe · worst · best. history: true is the day-by-day series of the headline numbers (days, default 90). Every row carries its n; under 30 is small. The same numbers as the track record page, recomputed at 01:15 UTC. The local server has no ledger, so its live layer says so.
keelage_pay hosted only
Input: optional tx, the hash of a USDG transfer to the merchant address, and optional wallet, your address (the same as the X-Wallet header; the argument wins when both are sent). With tx, the sending wallet is credited once with the amount, after 64 confirmations in the canonical chain. To spend it, every priced call carries X-Wallet-Sig (or the signature argument): a personal_sign of Keelage credit <address, lower case> <YYYY-MM-DD UTC> chain 4663 mcp.keelage.ai, good for its UTC day only; and optionally requestId (or X-Request-Id) so a retry is not charged twice: it is answered from the saved answer, told to retry while the first execution’s 120-second lease holds, or re-run free once that lease has lapsed. A priced call that has not answered within 100 seconds is cut off and refunded; retry it with the same request id. Without tx, that wallet's credit: balance, deposited, spent, paid calls, and the price list. Free, never counted. See x402.
Every priced answer (keelage_scan, keelage_holders, keelage_x) carries a credit line: the call's price, thisCall (what was charged and whether it came from the free quota or from credit), free (the calls used and left today, reset at 00:00 UTC), and the wallet and its balance when one was named.
keelage_today hosted only · free
Input: optional moment, one of code · activity · sized · watch. What we read today, as the Today page shows it: code (this hour's and today's code checks, each clean code, not clean or unread, with the reasons, launcher and first pool), activity (today's trading checks with the tier and sized or not sized), sized (the ones we'd put money in), watch (what changed since on passed tokens, by kind, and how many tokens are watched). Omit moment for all 4. Every row carries its time. The local server carries no store and says so.
keelage_token hosted only · free
Input: address. Everything the token's page on keelage.ai carries, as data: launch (creation block, time, factory, template), today's daily read (price, cap, pool, volume, holders), the scan's latest answer with its time, every time it passed with the 24-hour, 7-day and 30-day outcome, the hourly price series where we have it, the last 14 days of X reads, and the dated log of what changed. Unknown address: an error naming it. The local server carries no store and says so.
Every token on the chain is found. Only the ones with a live pool get a page.
These are the rules, in the order they run. Each one is a line of code and a number, and the numbers come from the same rules file every answer uses, so this page cannot drift from the system.
1. Found
Once a day we read every ERC-20 the chain's explorer lists, every address that has ever passed or shown in our hourly read, and every token the launchpads' factory contracts have created on chain. A token that exists on Robinhood Chain is found whether or not anyone is trading it.
2. Graduated, so in the universe
A found token joins the universe when DexScreener prices it from a pool on a DEX (Uniswap for nearly all of them) where the token is the base side and the pool holds liquidity. Graduation itself is read per launchpad from the launchpad's own event (Flap's LaunchedToDEX, Pons V2's PoolGraduated; for Doppler and CashCat the first pool without a hook; for the rest the pool their launch opened), and the landscape counts it that way. A token still on its launchpad's bonding curve has not graduated; it is counted in the launch statistics by launchpad and gets no page and no review until it does. No pool, or a pool that is empty, means the same. A token that launched and died the same day is counted and left alone.
3. Read every day
Every token in the universe is read once a day, around 00:00 UTC: price, market cap, pool, 24-hour volume, holders, first pool date. Its page carries the series. The launch read (creation transaction, factory, template) is made once and kept.
4. Judged every hour, from the first pool
Two checks, read at two times. The code check is read the hour a token’s pool first shows up in our hourly read, from the chain alone: verified source, a launcher the gate scores, no live owner privilege unless ownership is renounced, no transfer-tax code, no honeypot flag. It needs no trade to have happened. The trading check is the full structural gate, judged by the hourly scan from the first pool with no age floor and no pool floor (both 0 since 2026-10-06), at any market cap: the code check again, plus sells clearing, the pool not drained, how spread out the holders are, and whether we'd put money in (not up more than 30% today, real trades going through). Both floors were inherited from the first configuration and measured on every token, every day since each token’s first pool: age moved volatility, not the share worth more, and the tokens whose code passed were the one group with a positive 7-day median on their first day, so both came out. Their origin and every re-assessment sit on each line of the rules table. A token is judged once, the first day it trades $1,000 or more in 24 hours, youngest first, up to the run’s budget; after that it is judged again only when what changed since fires a trigger (sells stop clearing, the pool falls 70% from its peak, a large holder leaves), and carried with its last answer in between.
5. Passed, on a change
A token is marked passed when it gets through the structural gate for the first time, when a token that failed it now passes, or when a known passer becomes one we'd put money in. A score never admits a token; only the gate does. Every pass is timestamped, and its price is read again 24 hours, 7 days and 30 days later. A read with no pool left is recorded as no pair, never as -100%, and the record shows both treatments.
6. X, and the log
X is read as often as we read what changed since: hourly, every 6 hours or daily by market cap for passed tokens, and once for every new launch. Once a day the log on each page gains one dated line per change in price, pool, volume, holders or answer, computed from the reads above. No line is written by a person or a model.
The floors above are the sweep.* lines on the rules table, marked set by hand with the date they were set. When the record says a floor is wrong, the floor changes there and this page follows.
Every word we use, in plain English.
Two layers. The facts are measured from the chain and timestamped; they are the product and they don't move with the rules. The 3 words are our rules laid over the facts, under a named, dated set (today: keelage-default, 2026-10-10), every one of whose lines is still set by hand, so we're still tuning these and every answer says so. The 3 checks and their words first, with the 0.3 keys they map to, then every other term alphabetically.
1 · The code check still tuning
Clean code: verified source, a launcher we score, no live owner privilege unless renounced, no transfer-tax code, no honeypot flag. Not clean: one of those failed; the reasons are listed. Unread: a data source failed, so we don't know. Read the hour the pool appears; nothing here needs a trade.
2 · The trading check still tuning
Passes: the code check again, sells clearing in 24 hours, the pool not drained over 70% from its peak, the deployer under 5%, and how spread out the holders are. Fails: one of those failed; every reason is listed. Not judged: a data source failed, or the token has not traded like a project yet. Judged once, the first day the token trades $1,000 or more in 24 hours; after that we read what changed since.
3 · What we'd put in still tuning
Sized $X: the trading check passed, the price isn't up more than 30% today and real trades are going through; the dollars are a share of the pool by how spread out the holders are (1% spread out, 0.5% middling), never a buy. Not sized: the one reason, always stated: too concentrated (over the 45% line), up more than 30% today, a deep pool not trading, holders unknown, or the trading check did not pass.
The 0.3 keys, mapped. verdict.key still carries one of 4 words so nothing built on 0.3 breaks: ELIGIBLE = clean code, passes, sized. NOT_ELIGIBLE = clean code, passes, not sized. FAIL = the trading check fails; the code is clean or not clean, and verdict.moments.code says which. UNVERIFIED = unread, not judged, not sized. The same map sits on every answer as verdict.keys.
| Term | What it means here |
|---|---|
| Passed | A token that passed the structural checks at the hour our scanner saw it. We log its price then and read it again later. Every row in the track record is a passed token. |
| All-time high, "below peak" | The highest price the token has traded at. "57% below peak" means it trades at 43% of that. |
| 30-day low, distance, bands | The lowest price in the last 30 days, and how far above it the price sits now. We group the distance into 4 bands: at base (within 30%), just off base (30 to 100% above), well off base (100 to 500%), already ran (more than 500%). |
| Caps, unknowns | Facts we couldn't read. An unknown never fails a token; it caps what we'd put in. Every unknown is listed in the answer. |
| The code check, the trading check | The code check is what a token’s code answers the hour its pool appears: verified, a launcher we score, no live owner privilege, no transfer tax, no honeypot flag. The trading check is the full gate judged later, which adds sells clearing, the pool not drained, how spread out the holders are, and whether we'd put money in. The record shows what clean code on day 0 did next, separately from what passed tokens did. |
| Robinhood Chain, 4663 | The blockchain these tokens live on. 4663 is its chain ID, the number wallets and tools use to tell it apart from other chains. |
| Creator fees | On most launchers the deployer earns a cut of every trade. We read how much has been earned, claimed, and what the deployer did with it. |
| Deployer, creator | The wallet that created the token contract. "Deployer 0%" means it holds none of the supply now. |
| Would we put money in (the entry test) | The checks on top of the code check before we'd put money in a token: not up more than 30% today, and a pool over $100,000 must have traded at least 0.2% of itself in 24 hours. Until 2026-10-06 it also asked for at least 100 holders, $10,000 and 5% of market cap traded in 24 hours and, for the spread-out tier, at least 60% below the peak. The two volume floors and the peak line came off because the record showed each kept the worse side; the holder floor because the record could not test it and it stood on no measurement. |
| The field | Every token on the chain our daily read prices, over the same days as the tokens it's compared with, passed or not. A research trigger counts only when its tokens did better than the field, not better than zero, because in this market most tokens go down. |
| FOMO | A social trading phone app (fomo.family) with 2.7 million users as of October 2026, where most Robinhood Chain memecoin buys come from. It routes a buy from the user's USDC on Solana through the Relay bridge to Robinhood Chain. Keelage has no connection to FOMO; we read what its users' trades do on the chain like any other trade. |
| Structural checks, "the gate" | What we read from the chain about the code itself: is it verified, which launcher made it, can an owner mint, pause, blacklist, change fees or upgrade it, is there a transfer tax, did anyone sell in the last 24 hours, has the pool been drained, does the deployer still hold more than 5%, does any source flag it as a honeypot. Pass all of them or the answer is FAIL. |
| Honeypot | A token you can buy but not sell. We take the flag from two outside sources and we also look at whether sells actually went through. |
| Jev | A model's guess at the odds a token halves this week. The model, Jev, answers a typed question with a probability; we ask it "will this halve within 7 days?" and show the answer as context. The halving answer is shown in two ranges, under 50% and 50% and over, and the record page shows every day how often each range did halve; the "up in 7 days" answer carries no words. |
| In the pool, liquidity | The dollars sitting in the token's trading pool. Thin pools move a lot on small trades, so what we'd put in is measured against them: never more than 1% of the pool. |
| Market cap | Price times the number of tokens that exist. |
| MCP | Model Context Protocol, the standard way an AI agent connects to a tool. Keelage is an MCP server: your agent connects once and can call our tools. |
| Median | The middle result when every row is lined up from worst to best. Half did better, half did worse. We use it instead of the average because one 60x would hide 40 tokens that went to zero. |
| n | How many rows are behind a number. Under 30 is small; treat the number as a hint, not a fact. We print it next to every figure. |
| Project type | What the project is, as far as its name, symbol, launcher and X read say: meme, AI agent, DeFi, gaming, community, utility, RWA (a tokenized stock or asset), bridged major, NFT-backed, or unknown. A model reads it, or the factory fixes it (Virtuals agents, the stock factories, bridges, collection tokens); high, medium and low say how plainly. It describes the project, never its code: the gate reads every type the same way, and the record shows what each type did. |
| Reasons | The evidence that failed a token. Only evidence blocks; an unknown never does. Every reason is listed on the verdict. |
| RPC | The address your software uses to talk to the chain. The local server uses the public one unless you give it your own. |
| Our hourly read, the scanner | Our hourly process. It reads every token it can find on Robinhood Chain, runs the checks, and logs the result with a timestamp. Running since July 2026, Robinhood Chain only since 9 Sep 2026. |
| Score | A number that orders tokens in our hourly read. It never admits or rejects one, and in our studies it didn't predict returns, so it's the last tiebreak. |
| What we'd put in, the size rule | How much we'd put in, in dollars, when a token passed: a share of the pool by how spread out the holders are, 1% when spread out, 0.5% when middling. No dollar cap since 2026-10-06; the record tests the share. |
| Robinhood app wallet, smart account | Wallets created inside the Robinhood app read on the chain as EIP-7702 smart accounts. We count them among the holders so you can see how much of a token is held by app users. |
| Paid takeover claim | A listing a new team can buy on DexScreener to say they've taken over an abandoned token. In our study tokens carrying one did far worse than tokens without, so it shows as a caution and counts for nothing. |
| Transfer tax | Code that skims a cut of every transfer to someone's wallet. We read the contract for it. Pool fees, which every token pays to the exchange, are not a transfer tax. |
| Launcher, template | A factory contract that deploys the same token code for anyone who pays. Pons alone made most of the tokens on this chain; the landscape counts every launch by launcher. We judge the launcher's code once and every token from it inherits that judgement. "No launcher" means somebody wrote the contract by hand. |
| Third-party safety score | Services like GoPlus publish a safety rating for tokens. We read them for corroboration only; they never admit or reject a token here, the gate reads the chain. |
| How spread out the holders are (the tier), the 30% and 45% lines | How concentrated the holders are, used to cap what we'd put in. Spread out (conviction): the 10 largest wallets hold 30% or less and the pool is $50,000 or more. Middling, thin pool (scout): 30% or less, pool under $50,000. Middling, cluster check (scout): 30 to 45%. Too concentrated (watch only): over 45%, never sized. Where the lines come from. The 30% line is from a 2025 study of 34,988 meme coins across 4 chains (arXiv 2507.01963, read July 2026): the 10 largest holders owning over 30% of the supply was the most common anomaly, present in 87.14% of the anomalies it detected. The 30 to 45% band is our own buffer, where we ask for a check on whether those wallets are one group. Above 45% a handful of wallets can set the price on their own, so we don't size at all. The live tier table on the record shows what each tier did, cut daily. So the line is about one holder being able to dump on you, not about expected return. Both numbers get re-tested as the record grows. |
| 10 largest wallets | The share of the supply held by the 10 biggest holders, with trading pools and other contracts taken out so you see people, not plumbing. Also written "top-10". |
| Research trigger, worth another look | Up to 3 facts we read on a token at one moment, such as its market cap and its age, found on older tokens and then tested on later tokens it never saw, read 24 hours, 7 days or 30 days on. Under the policy set on 2026-10-10 one holds up only with at least 100 tokens on each side of that split, and a row under 30 tokens is gray. The list is cut every night and is good for 36 hours. It's research, not a recommendation: it never changes a check or what we'd put in. |
| Trimmed mean | The average after the top and bottom 5% of results are dropped: with 120 tokens, 6 come off each end. It keeps one 60x from carrying the number and still feels the big moves the median ignores. |
| USDG | A dollar stablecoin on Robinhood Chain. Paid calls are priced in it. |
| Verified code | The contract's source code has been published and the explorer confirmed it matches what's on the chain. Unverified code means nobody can read what the contract does. |
| x402 | A way for a server to answer "pay 0.05 USDG first" and for your agent to pay and retry, with no account or card. Ours is the receipt form: you send USDG to the merchant address on the ledger, register the transaction once with keelage_pay, and the wallet that sent it is credited. Priced calls past the free 20 a day draw on that credit when you send the X-Wallet header. The server reads the chain and never holds a key; the X-Wallet-Sig header is your wallet's own signature of a dated message, proving the address is yours. |
Anything we store, you can ask for.
Tools and fields are declared by the server, so your agent sees new ones the next time it connects. These are the ones in the build queue, in order.
| Tool | What it will answer | Needs |
|---|---|---|
| request form, stored and notified | The request a metric form writes to our own database first and then emails us, so nothing is missed. | Live |
| lines from the record | Every threshold in the rules (30% and 45% concentration, the former $10,000 and 5% trading floors, 5% deployer share) tested every day on the record page, on every passed token and on every token, every day since each token's first pool; a value changes by decision, with the date on its line. Pool depth and holder lines wait for their facts to age in. | Live |
| app-wallet share | On the holder map: the share of a token held by wallets that were filled through the Relay bridge, which is how FOMO and similar apps deliver tokens. So you can see how much of a token sits with app users versus wallets that bought on the chain directly. | Relay fill history per wallet |
| keelage_fees | Creator fees earned, claimed, unclaimed. Dev wallet buys, sells, burns, bridge-outs. A flag when the pattern flips. | Fee-escrow and dev-wallet reads |
| keelage_history | Every past answer on a token, with its 24-hour and 7-day outcome. | The hourly publisher |
| keelage_exit | Route and slippage to ETH for your position size, quoted from live pools. | Pool quoting |
| keelage_creator | Earlier launches from the same deployer and how each one ended on our log. | The hourly publisher |
| keelage_watch | A push when a watched token's gate breaks, top-10 drifts, or liquidity halves. | Hosted server |
Already here: the ruleset argument
The 3 words are our rules laid over the facts. The facts don't move; the lines the policy reads can. ruleset on keelage_scan says which lines. Leave it out and you get keelage-default, the lines on the track record page. It's the only preset today. "default" is accepted as its short form.
Or pass your own lines over it: { "lines": [{ "key": "pool.deep", "value": 100000 }, { "key": "top10.scout", "value": 35 }] }. A key is one of the lines below, with a number in that line's unit. A key we don't know, a value of the wrong shape, or a key given twice comes back as an error, not a verdict. One line can't be moved, jev.halveBands, because the two range words of the model's guess are tied to the 50% cut.
Every answer names what it ran under, in verdict.ruleset: name (keelage-default, or custom for your own lines), date (the preset's date, or today for your own lines) and overrides, the keys whose value differs from the default, empty for a preset.
| Key | Unit | Default | What it decides |
|---|---|---|---|
| top10.conviction | % of supply | 30 | Spread-out tier (conviction): the 10 largest wallets hold this much or less |
| top10.scout | % of supply | 45 | Above this the holders are too concentrated (watch only) and we'd put nothing in |
| pool.deep | USD in the pool | 50,000 | The spread-out tier needs a pool at least this deep; thinner pools take the middling share |
| size.poolShare | % of the pool | 1 | Spread-out size: this share of the pool, in dollars. The $1,000 and $100 dollar caps came out on 2026-10-06 (hand-set, no source) |
| size.poolShare.scout | % of the pool | 0.5 | Middling size: this share of the pool |
| activity.triggerVolume24h | USD traded in 24h | 1,000 | Cadence, not an answer: the trading check runs once, the first day a token trades this much |
| watch.minMcapUsd · watch.sixHourlyMcapUsd · watch.hourlyMcapUsd | USD market cap | 50,000 · 250,000 · 1,000,000 | Cadence, not an answer: a passed token is read for what changed from the first, every 6 hours from the second, every hour from the third |
| deployer.max | % of supply | 5 | A deployer still holding more than this fails the token |
| holders.min | wallets | 0 | Off since 2026-10-06 (0 = the check does not run); was a 100-wallet floor the record could not test |
| entry.midPump | % price change in 24h | 30 | Up more than this today means we'd put nothing in |
| entry.minVolume24h | USD traded in 24h | 0 | Off since 2026-10-06 (0 = the check does not run); was a $10,000 floor |
| entry.minTurnoverOfMcap | % of market cap traded in 24h | 0 | Off since 2026-10-06 (0 = the check does not run); was a 5% floor |
| entry.deepPoolTurnover | % of the pool traded in 24h | 0.2 | A pool over $100,000 doing less than this reads as fabricated or dead |
| entry.convictionBelowPeak | % below all-time high | 0 | Off since 2026-10-06 (0 = the check does not run); the spread-out tier no longer needs a decline from peak |
| liquidity.maxDrawdown | % below its recorded peak | 70 | A pool drained more than this fails the token |
| base.atBase | % above the 30-day low | 30 | At base band ends here |
| base.justOff | % above the 30-day low | 100 | Just off base band ends here |
| base.wellOff | % above the 30-day low | 500 | Well off base band ends here; beyond is already ran |
| jev.halveBands | probability | 0.5 | Two ranges for the model's guess: under 50% (unlikely to halve this week) and 50% and over (may well halve) |
A stricter preset isn't in this release. We ship one only when every line it moves has a documented source: an earlier value stated in that line's own origin, or a measurement on the live record. Today 1 line has one: pool.deep was 100,000 before 2026-08-01. The others are set by hand or measured at their current value, and we don't invent the stricter number.
What changed, and when.
| Date | Version | Change |
|---|---|---|
| 2026-10-10 | 0.5.0 | Research triggers on keelage_scan, keelage_record, keelage_today and keelage_token: a dated signals block beside each answer, with every legacy key unchanged. It reads not public until the owner switches it on. keelage_today and keelage_token take a cursor input for the next page of matches. |
| 2026-10-08 | 0.4.1 | Audit fixes. The 10 largest wallets are counted after pools and contracts are set aside (rows past 10 are read), so a top-heavy explorer page no longer understates concentration. A GeckoTerminal honeypot flag is kept when the holders block is missing. Even-count medians average the middle pair. The price-history cache keeps the candle facts only, per pool and side; distance from the 30-day low and drawdown from ATH are recomputed from the live price on every scan. The CoinGecko key travels only to CoinGecko. The CLI exits non-zero on an answer that is not ok and never reads X on a scan (the same as the server). Hosted: the free quota counts by network caller, a priced call is charged before it runs and refunded on an error, a call with no id runs nothing. |
| 2026-10-06 | 0.4.0 | The 3 moments on every answer: keelage_scan's verdict carries code (clean code, not clean, unread), activity (passes, fails, not judged) and size (sized, not sized) with their reasons, and keeps the 0.3 key beside them, mapped. keelage_today: what was read today (code passes, activity passes, sized, the watch), free. Hosted server: wallet as an argument on keelage_pay and every priced tool beside the X-Wallet header, and a credit line on every priced answer (this call's price and where it was paid from, the free calls left today, the balance). Holder growth joins the record: every pass cut by how its holder count moved over the 7 days after the pass, every token-day by the prior and the next 7 days, and the pool read on every token-day with pool.deep tested there. |
| 2026-10-06 | 0.3.0 | No dated studies anywhere: keelage_record answers with the rules and the live record only (the bundled study file is gone), Jev reads in two ranges, the sweep has no age floor, conviction no longer needs a decline from peak, and every rule line is tested daily on every pass and every token-day since each token's first pool. |
| 2026-10-05 | 0.2.1 | keelage_record carries the live record: every alert's outcome rows re-cut daily by horizon, 30-day-low band, tier, market cap, pool, age, day-one move, takeover claim, Jev band, X posts, X tone and alert kind, one table at a time or all at once, with the day-by-day series. The track record page shows the same cut at the top. |
| 2026-10-05 | 0.2.0 | keelage_x: what X is saying about a token in the last 24 hours, as its own call at 0.02 USDG; a scan no longer reads X. Hosted server: prepaid USDG credit. Send USDG to the merchant address on the ledger, register the transaction once with keelage_pay, and priced calls past the free 20 a day draw on it. |
| 2026-10-05 | 0.1.2 | Published to npm as @keelage/mcp; the hosted server at mcp.keelage.ai runs the same code. The server now reports its package version. |
| 2026-10-04 | 0.1.1 | keelage_scan takes an optional ruleset: keelage-default (the only preset) or your own lines over it. Every verdict names its ruleset, date and overrides. |
| 2026-10-04 | 0.1.0 | First release: keelage_scan, keelage_holders, keelage_template, keelage_record over stdio. 5 reference tokens held to their structural verdict in the live test. |