docs · @keelage/mcp 0.5.0

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.

KeyWhat it holds
verdictmoments 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 · scoreHow 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).
sizeusd 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.
marketPrice, liquidity, market cap, 24h volume, buys and sells, 24h change, age in days, the pair and dex, the quote symbol.
locationPercent below ATH, percent above the 30-day low, the base band in words, ATH and low values, median daily range over 14 days.
structurePass 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.
holdersCount, 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.
goplusCorroboration only: honeypot flag, buy and sell tax, mintable, pausable, LP mode and LP holder statistics. record:false when GoPlus has nothing.
takeoverClaim · discoveryShape · jevA 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 · disclaimerDexScreener, GeckoTerminal and Blockscout pages. The timestamp. "Research only, not financial advice."

keelage_holders

Input: address, optional smartAccounts (default true). The holder map.

KeyWhat it holds
holderCount · totalSupplyFrom the explorer.
top10Share excluding pools and contracts, share including pools, largest wallet, how many contracts and pools sit in the top 10.
burnPctShare held by the zero, dead and 0x1 addresses.
smartAccountsHow many of the listed wallets are EIP-7702 delegated accounts (how the Robinhood app wallet reads), and their combined share.
holdersUp 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 · creatorPctEvery 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.

KeyWhat it holds
templateKey (one of the launcher templates the landscape counts, or unregistered), verdict, what it matched on, the fee model, and the census note.
contractVerified source and when, compiler, contract and implementation names, proxy type, creator, function count.
privileges · livePrivilege · taxCodeOwner 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.

KeyWhat it holds
query · queryModeWhat 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 · replies24Counts over the 24-hour window. Reposts are counted separately in rts24.
copyPasteShare · toneThe share of posts that repeat one template, and what that implies: organic, campaign, or mixed.
accountsBig · bigAccounts · medianFollowersHow 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 · otherChainMentionsPosts that name Robinhood Chain, and posts that name another chain. A ticker is not a token.
meta · big · lineA 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 · sourcesWhen 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.

TermWhat it means here
PassedA 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, bandsThe 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, unknownsFacts 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 checkThe 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, 4663The blockchain these tokens live on. 4663 is its chain ID, the number wallets and tools use to tell it apart from other chains.
Creator feesOn 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, creatorThe 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 fieldEvery 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.
FOMOA 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.
HoneypotA 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.
JevA 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, liquidityThe 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 capPrice times the number of tokens that exist.
MCPModel 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.
MedianThe 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.
nHow 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 typeWhat 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.
ReasonsThe evidence that failed a token. Only evidence blocks; an unknown never does. Every reason is listed on the verdict.
RPCThe 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 scannerOur 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.
ScoreA 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 ruleHow 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 accountWallets 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 claimA 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 taxCode 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, templateA 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 scoreServices 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% linesHow 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 walletsThe 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 lookUp 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 meanThe 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.
USDGA dollar stablecoin on Robinhood Chain. Paid calls are priced in it.
Verified codeThe 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.
x402A 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.

ToolWhat it will answerNeeds
request form, stored and notifiedThe request a metric form writes to our own database first and then emails us, so nothing is missed.Live
lines from the recordEvery 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 shareOn 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_feesCreator fees earned, claimed, unclaimed. Dev wallet buys, sells, burns, bridge-outs. A flag when the pattern flips.Fee-escrow and dev-wallet reads
keelage_historyEvery past answer on a token, with its 24-hour and 7-day outcome.The hourly publisher
keelage_exitRoute and slippage to ETH for your position size, quoted from live pools.Pool quoting
keelage_creatorEarlier launches from the same deployer and how each one ended on our log.The hourly publisher
keelage_watchA 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.

KeyUnitDefaultWhat it decides
top10.conviction% of supply30Spread-out tier (conviction): the 10 largest wallets hold this much or less
top10.scout% of supply45Above this the holders are too concentrated (watch only) and we'd put nothing in
pool.deepUSD in the pool50,000The spread-out tier needs a pool at least this deep; thinner pools take the middling share
size.poolShare% of the pool1Spread-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 pool0.5Middling size: this share of the pool
activity.triggerVolume24hUSD traded in 24h1,000Cadence, not an answer: the trading check runs once, the first day a token trades this much
watch.minMcapUsd · watch.sixHourlyMcapUsd · watch.hourlyMcapUsdUSD market cap50,000 · 250,000 · 1,000,000Cadence, 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 supply5A deployer still holding more than this fails the token
holders.minwallets0Off 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 24h30Up more than this today means we'd put nothing in
entry.minVolume24hUSD traded in 24h0Off since 2026-10-06 (0 = the check does not run); was a $10,000 floor
entry.minTurnoverOfMcap% of market cap traded in 24h0Off since 2026-10-06 (0 = the check does not run); was a 5% floor
entry.deepPoolTurnover% of the pool traded in 24h0.2A pool over $100,000 doing less than this reads as fabricated or dead
entry.convictionBelowPeak% below all-time high0Off 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 peak70A pool drained more than this fails the token
base.atBase% above the 30-day low30At base band ends here
base.justOff% above the 30-day low100Just off base band ends here
base.wellOff% above the 30-day low500Well off base band ends here; beyond is already ran
jev.halveBandsprobability0.5Two 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.

DateVersionChange
2026-10-100.5.0Research 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-080.4.1Audit 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-060.4.0The 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-060.3.0No 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-050.2.1keelage_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-050.2.0keelage_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-050.1.2Published 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-040.1.1keelage_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-040.1.0First release: keelage_scan, keelage_holders, keelage_template, keelage_record over stdio. 5 reference tokens held to their structural verdict in the live test.