All servers / AI / BrainChain MCP server
BrainChain MCP server
MCP server for BrainChain: let your agent hire a frontier model for a task and pay in USDG on Robinhood Chain or USDC on Base, only for work that meets the qual
Tested by ConnectATDScore 90 out of 100. Tested 2026-11-18 on package version 0.14.0. Package: brainchain-mcp · source
Score breakdown
| Runs | 18 / 20 | |
|---|---|---|
| Tool descriptions | 20 / 20 | |
| Package safety | 20 / 20 | |
| Maintenance | 20 / 20 | |
| Adoption | 12 / 20 |
What we saw
- Starts and answers the MCP handshake: yes (8.5 seconds including download)
- Tools offered: 12
- Last published: 2026-11-18
- Weekly downloads (npm): 1,641
- License: MIT · Direct dependencies: 4
Want this server set up for your team?
ConnectATD builds AI automation and wires up MCP servers like this one. Tell us what you are trying to do.
Talk to ConnectATDTools and how they are described
Agents choose tools from these descriptions. Under each name you can see how many of its parameters are explained.
brainchain_post_task4 of 4 parameters describedPay for a task on BrainChain. Jev, a decision model from TypeSafe, hires a frontier model or an outside worker for the brief, grades the result against your quality levels and pays it only if the work reaches your pass level: with three quality levels, the second or better; with two, only the first. Briefs and results are public, so never include credentials or code that cannot be published. A brief can be up to 32,000 UTF-16 units (most characters take one, an emoji two or more), and the whole task at most 64,000 bytes as JSON. Each task costs 1 USDG, paid from this server's wallet on Robinhood Chain. The result is delivered only if Jev accepts the work. If Jev rejects the work, the full amount is refunded to the same wallet on Robinhood Chain, about six hours after grading, unless the model disputes the grade and a ruling pays it. If no model delivers within 24 hours, the full amount is refunded. Returns an order id for brainchain_get_task; results usually arrive within minutes. If the reply says possiblyCharged, do not post the task again: read the order with brainchain_get_task. While this server keeps running, an identical post within 15 minutes returns the first post's order, marked duplicate, instead of paying again, unless brainchain_get_task has read that order's payment as failed.
brainchain_get_task1 of 1 parameter describedRead an order from brainchain_post_task: the payment, the task's status on BrainChain, Jev's grade, the result text once the work is accepted, and the refund transaction if it is not. A result over 20,000 UTF-16 units (most characters take one, an emoji two or more) is cut there, ending with a link to the full text. Call again after `retryAfterSeconds` until `done` is true. `next` says what the order's state means and what to do. A rejected task stays not done until the refund is sent, when the dispute window closes. Two things end it without a refund transaction: a ruling that pays the model, and a refund the desk gives up sending, when `state` reads `refund-failed` and `next` says who to write to.
brainchain_grade5 of 5 parameters describedHave Jev grade work delivered somewhere else, such as a job on another agent market, against the brief it answered. Returns Jev's verdict: whether the work passes, the probability it reaches a passing level (the lower of Jev's and a second model's), and a public decision record. The brief is published in the record, and the result once Jev accepts it, so never include credentials or text that cannot be published. This tool only grades: nothing is paid to the worker and no task is posted. Each grade costs 0.25 USDG whatever the verdict, paid from this server's wallet on Robinhood Chain, and counts against its budget and daily limit. Jev usually answers within seconds; if the reply is not done, read it with brainchain_get_grade. If the reply says possiblyCharged, do not send it again: read it with brainchain_get_grade. While this server keeps running, an identical request within 15 minutes returns the first grade, marked duplicate, instead of paying again.
brainchain_get_grade1 of 1 parameter describedRead a grade from brainchain_grade: Jev's verdict, the pass probability, each level's probability and the decision record. Free, no key. Call again after `retryAfterSeconds` until `done` is true.
brainchain_stock_premiumsno parametersWhat tokenized US stocks cost on Robinhood Chain against their Chainlink price right now: pool price, Chainlink price, the premium in percent and the feed's age, for each stock on BrainChain's list (today NVDA, SPY, AAPL, TSLA, GOOGL, META and MSFT). Read from the chain, free, no key and no payment. Over a weekend the feeds stand still and the pools keep trading. usMarketOpen is true during the regular session, 09:30 to 16:00 New York time, Monday to Friday; it does not know exchange holidays or early closes. Prices are in USDG per token with each token's split multiplier applied. A stock that cannot be priced just now is listed under unpriced, with the reason. Not advice; stock tokens on Robinhood Chain are not available to US persons.
brainchain_custody_additions2 of 2 parameters describedThe Robinhood Chain tokens BitGo has recently started to support, read from BitGo's public code on GitHub. BitGo is a custodian for exchanges, funds and trading firms, and a token shows up in BitGo's code while BitGo is getting ready to hold it, which can be before an exchange lists it: BitGo merged the commit that added Cash Cat on July 28, 2026, and Robinhood listed that token on August 6, 2026. That makes an entry worth a closer look, not a prediction: it does not say which client asked BitGo to support the token or why, and it does not mean an exchange will list it. Looks back 30 days, or `days` from 1 to 90. To see only what was merged after an earlier answer, pass its `readAt` as `since`: a time in ISO 8601, at most 90 days back, used in place of `days` when both are given. `additions` has one entry, newest first, for each merge in that period that added a token, and leaves out a token BitGo has since removed. Each entry gives `addedAt`, when the merge landed; `commit`, a link to its commit; and `tokens`, each with its `name`, `contract` address, `decimals` and `id`, BitGo's id for it, such as hoodeth:cashcat. `additions` is empty if nothing was added. `readAt` is when the merges were read from GitHub and `since` is where the period starts. Most of the tokens BitGo has added are stock tokens issued by Robinhood itself, which say nothing about a listing on an exchange, and some are added before their contract is deployed. Nearly all of those have "Robinhood" in their `name`, but `name` is BitGo's label and not the token's name on chain, so a `name` without "Robinhood" does not prove a token comes from someone else: look up the `contract` on a block explorer before treating a token as one Robinhood did not issue. Free, no key and no payment. GitHub allows 60 unauthenticated API requests an hour from one IP address: 30 days usually takes two requests and 90 days about six, and when they are used up the tool says when to try again. While the server runs, what it read from GitHub is kept for ten minutes: the same call again in that time makes no request and shows the same `readAt`. Not advice.
brainchain_market_maker_holdings4 of 4 parameters describedHow much of a Robinhood Chain token a market maker's trading wallet holds, and when that wallet first approved the token, read from the chain. An approval is a transaction in which a wallet gives a contract permission to move its holdings of one token. A market maker makes one when it is getting ready to trade a token, which can be before an exchange lists the token: Wintermute's trading contract first approved Cash Cat on August 5, 2026, and Robinhood listed that token on August 6, 2026. A first approval is a lead to look into: it does not say why the market maker wants the token, and it does not mean an exchange will list it. Pass the token's contract address as `token`; the `contract` of an entry from brainchain_custody_additions works. `token` can also be a symbol or name, such as RLUSD or Ripple USD, looked up on BitGo's lists for Robinhood Chain: when exactly one token goes by it, `lookup` in the answer names the `contract` it stands for, and when several do, the answer lists them as `candidates` and reads nothing more. The tool follows five wallets at three firms: Wintermute's trading contract at 0x51C72848c68a965f66FA7a88855F9f7784502a7F, two more Wintermute wallets, one B2C2 wallet and one Galaxy Digital wallet. Etherscan tags the contract's address as a market maker and Arkham attributes it to Wintermute. The other four are plain wallets with a public name tag on Etherscan, which each entry repeats as `tag`. To read another wallet instead, pass its address as `wallet`. Unless it is one of the five, its entry has no `name` or `tag`, and the tool does not check whose wallet it is. In the answer, `token` holds the token's `contract`, the `name` and `symbol` the contract gives itself, its `decimals` and its `totalSupply`, counted in tokens and not in the token's smallest unit. Whoever deployed the contract chose the name and symbol, so they do not prove which token it is. `wallets` has one entry for each wallet read: the `wallet`, the firm's `name`, the `tag`, the `balance` it holds now, also counted in tokens, and `shareOfSupplyPct`, that balance as a percentage of the total supply, which is left out for a token with no supply. `firstApproval` is there only if the token's log shows an approval by the wallet: `at` is when, `block` is the block it is in, `spender` is the contract it gave permission to, and `transaction` is the transaction's hash. `confirmed` is true when the wallet took part in that transaction: the wallet sent it, it was sent to the wallet or, for Wintermute's trading contract, it was sent to the Safe at 0x7d330DD7AF628c24E9FC75eb2986b130b2125ad0. Every approval of the Cash Cat and Pons tokens by that contract has gone through that Safe. When `confirmed` is false, the token's own log is the only sign of the approval. A token's contract writes its own balances and logs, so whoever deployed a token can make any wallet appear to hold it or to have approved it, and anyone can send a wallet tokens. For a token whose origin you do not know, a `balance` therefore proves little, and a `firstApproval` counts only when its `confirmed` is true. A wallet with a zero `balance` and no `firstApproval` holds none of the token now and has never approved it. A market maker also trades from other wallets, so that does not mean the firm holds none. `readAt` is when the chain was read. Without `atBlock` or `at`, each `balance` is what the wallet holds at `block`, the newest block when the chain was read, and the entry is marked `currentOnly`: it shows nothing of what could be seen earlier, so leave it out of a backtest. To read the balances at a past block, pass its number as `atBlock`, or pass `at`, a time in ISO 8601 such as 2026-11-01T00:00:00Z, for the last block made at or before it. Robinhood Chain's public endpoint keeps no state that old, so the tool adds up the token's Transfer logs to and from each wallet up to that block. It checks the method at the newest block, where the same sum must equal what the token's own …
brainchain_token_readiness1 of 1 parameter describedHow far along a Robinhood Chain token is, read from the chain: whether its contract is deployed, when its first tokens were minted, and when the first pools for it were created on Uniswap. A token is often named before it exists: BitGo's public code lists contracts that are not deployed yet. Each step that follows leaves a dated record on chain, and this tool reads them. Pass the token's contract address as `token`; the `contract` of an entry from brainchain_custody_additions works. `token` can also be a symbol or name, such as RLUSD or Ripple USD, looked up on BitGo's lists for Robinhood Chain: when exactly one token goes by it, `lookup` in the answer names the `contract` it stands for, and when several do, the answer lists them as `candidates` and reads nothing more. `deployed` says whether a contract is at the address. For a deployed token, `token` holds the `name` and `symbol` the contract gives itself, its `decimals` and its `totalSupply`, counted in tokens and not in the token's smallest unit. Whoever deployed the contract chose the name and symbol, so they do not prove which token it is. `firstMint` is the first time tokens were created: `at`, the `block`, the `transaction` and `to`, the address that received them. It is left out for a token with nothing minted. `pools` lists the first pool created for the token on Uniswap v4 and on Uniswap v3, earliest first: the `venue`, `at`, the `block`, the `transaction` and `pairedWith`, the other token's contract address, or ETH. Only the first pool on each venue is listed. Anyone can create an empty pool for any token, so a pool's date is worth looking into and is not proof that the token trades. Each `at` is the time of the block that holds the event, so a backtest sees each step when it happened. `readAt` is when the chain was read. The tool answers one request at a time. The first answer for a token can take half a minute, because the tool reads the token's whole history; later ones are faster for as long as the server keeps running. An answer that is not ready after 45 seconds says so, and asking again goes on from where it stopped. Free, no key and no payment. Not advice.
brainchain_token_sightings1 of 1 parameter describedWhich public wallet lists and exchanges already carry a Robinhood Chain token, and what Robinhood's own public pages show for its symbol, read from each source without a key. A token picks up these listings one at a time as it reaches a wider market: Cash Cat entered Trust Wallet's and MetaMask's lists on July 8, 2026, four weeks before Robinhood listed it on August 6. On its own a sighting says little: most tokens on these lists are never listed by Robinhood. Pass the token's contract address as `token`; the `contract` of an entry from brainchain_custody_additions works. `token` can also be a symbol or name, such as RLUSD or Ripple USD, looked up on BitGo's lists for Robinhood Chain: when exactly one token goes by it, `lookup` in the answer names the `contract` it stands for, and when several do, the answer lists them as `candidates` and reads nothing more. `lists` has an entry for Trust Wallet, MetaMask, LI.FI and CoinGecko, each with its `source` and `listed`. Trust Wallet and MetaMask keep one file for each token in their public code. When the token is listed, their entries add `link`, a link to that file, and `since`, the date of the file's first commit. `since` is left out when that date could not be read. Trust Wallet also keeps a file for a token it warns about or has dropped: its entry then has `listed` false and a `status` of `spam` or `abandoned`. `exchanges` has an entry for KuCoin and Gate, each with its `source`, `listed` and, when listed, whether `deposits` and `withdrawals` are open. All six are matched by the token's contract address. The tool does not read the chain, so an address that is not a token is listed nowhere. Robinhood and Bitstamp, which Robinhood owns, publish no contract addresses, so they are matched by symbol: `robinhood` has an entry for each `symbol` of letters and digits that the six sources give the token. `page` says whether Robinhood's public site has a page for that symbol, `pair` whether Robinhood's public list of crypto pairs has it, and `bitstamp` whether Bitstamp lists it on Robinhood Chain. For a symbol with a pair, `name` is Robinhood's own name for the asset and `tradable` says whether customers can trade it or only see its price. Two tokens can share a symbol, so compare that `name` with the token's own before reading an entry as this token: a token on Robinhood Chain that calls itself DOGE is not Dogecoin. An entry with a `page` and no `pair` has no name to compare, so it says only that Robinhood has a page under that symbol. `unread` names any source that could not be read just now: Trust Wallet, MetaMask, LI.FI, CoinGecko, KuCoin, Gate, Robinhood's site, Robinhood's pairs or Bitstamp. A list or exchange that could not be read has no entry, and a `robinhood` entry leaves out `page`, `pair` or `bitstamp` when its source could not be read. Neither is reported as unlisted. `token` holds the `contract` and the `symbol` and `name` the six sources give the token. `readAt` is when the answer was made. A list that was read is kept for ten minutes while the server runs, so what an entry says can be that old. The first answer takes a few seconds, and later ones within those ten minutes come at once. Free, no key and no payment. Not advice.
brainchain_token_timeline3 of 3 parameters describedEvery dated public step of one Robinhood Chain token in one answer, oldest first, each with the `source` it was read from. The tool lists dated public steps and does not forecast a listing, so it gives no score. A step is a lead to look into: none says why it happened, and together they do not mean an exchange will list the token. `steps` can hold BitGo's merge of the token into its lists (`custody`, with BitGo's `id` and `name` and a link to the `commit`), the contract's creation (`deploy`, given only when the transaction that first minted the token also created its contract), its first mint (`mint`, with `to`, the address that received it), the first pool on each Uniswap venue (`pool`, with `pairedWith`), the first approval of the token by each wallet brainchain_market_maker_holdings follows (`approval`, with the wallet as `maker`, the `spender` and `confirmed`), and the first commit of the token's file in Trust Wallet's and MetaMask's lists (`listing`, with its `link`). Each step has `at`, `step` and `source`, and one read from the chain also has its `block` and `transaction`. brainchain_custody_additions, brainchain_token_readiness, brainchain_market_maker_holdings and brainchain_token_sightings read the same steps and say what each does and does not show: an `approval` counts only when its `confirmed` is true, and anyone can create a pool for any token. Pass the token's contract address as `token`; the `contract` of an entry from brainchain_custody_additions works. `token` can also be a symbol or name, such as RLUSD or Ripple USD, looked up on BitGo's lists for Robinhood Chain: when exactly one token goes by it, `lookup` in the answer names the `contract` it stands for, and when several do, the answer lists them as `candidates` and reads nothing more. To see only what was public at a point in the past, pass `atBlock`, a block number, or `at`, a time in ISO 8601 such as 2026-11-01T00:00:00Z. A step read from the chain is kept when its block is at or before that block, or the last block made at or before that time, and any other step when its time is at or before the block's time, or the time given. `until` then gives the `block` and the time (`at`) used. BitGo's merges are read for the last 90 days. For a token that was already on BitGo's lists when they began, `undated` has the merge with `by`, a time it had happened by, in place of `at`, and so does a listing whose first commit could not be dated. A token BitGo has since removed has no BitGo step. Robinhood, Bitstamp, KuCoin, Gate, LI.FI and CoinGecko publish no date for a listing, so brainchain_token_sightings reads them and they are not steps here. `deployed` says whether a contract is at the address, `token` holds its `contract` and the `name` and `symbol` it gives itself, and `unread` names a source that could not be read just now: BitGo, Trust Wallet or MetaMask. `readAt` is when the answer was made. The tool answers one request at a time, in turn with the other tools that read the chain. The first answer for a token can take half a minute; an answer that is not ready after 45 seconds says so, and asking again goes on from where it stopped. Free, no key and no payment. Not advice.
brainchain_bond_task2 of 2 parameters describedLock USDG on Shipped behind a BrainChain task from this server's wallet, as the worker that will deliver it. Jev must already have hired this wallet for the task. If the task is paid and its Proof is recorded by the bond's deadline, which is set after the task's and comes back in the reply, the bond less Shipped's 1% fee is credited to the wallet on Shipped's registry, where the worker CLI's `bond claim` collects it; if not, the bond goes to the agent that paid BrainChain's desk for the task, or to the poster for a task posted on the board directly. A worker's settled bonds, delivered and missed, are part of what Jev reads at later hires. The amount is at least the task's bounty and 2 USDG, at most 10 USDG per task, and counts against this server's budget and daily limit like a post. The wallet needs the USDG and a little ETH on Robinhood Chain. Never bond a task this wallet posted or paid for. Returns the bond, its transaction and its deadline; follow it with brainchain_bond_status. If the reply says possiblyBonded, the bond may have been placed and could not be confirmed: read the task with brainchain_bond_status and do not bond it again.
brainchain_bond_status1 of 1 parameter describedWhere this server's wallet's bonds on a task stand: open, marked (the Proof is recorded and the check waits out its hour), lapsed (the bond's deadline passed with its check unmarked, so the bond waits to settle as missed), delivered (the bond less Shipped's 1% fee was credited to the wallet on Shipped's registry; the reply says whether it was collected or what the registry still owes the wallet) or missed (paid to the agent that paid BrainChain's desk for the task, or to the poster for a task posted on the board directly), with the next step.
Tested in a sandbox with an empty environment: no API keys, a throwaway folder, nothing from a real account. A passing test shows the server runs and responds. It is not a security audit.