RobinX MCP

The Model Context Protocol is an open standard for handing a model tools. Publish a capability once as an MCP server and any MCP-capable client — Claude Desktop, Cursor, your own agent — can call it without a bespoke integration. It is a port, not a plug: the thing you build against once instead of rewriting for every model that ships next quarter.

RobinX MCP is that port for Robinhood Chain.It takes a chain — an append-only ledger that answers only the questions you already know how to ask — and turns it into something an agent can interrogate. Not an endpoint the app calls on the user's behalf. A tool the model calls, on its own initiative, mid-thought, because it decided the answer required it.

>Is 0x7f3a…c9d2 safe to ape?

Nobody wired that sentence to a function. The agent read it, decided it needed the contract source, the liquidity lock, the holder concentration, and the deployer's history, called four different tools to get them, noticed that two of them disagreed, and said so. That is the entire difference between a search box and an agent, and RobinX MCP is what makes the second one possible.

The loop runs up to four iterations in Auto and Fast, and up to six in Deep — each iteration free to call more tools based on what the last one returned. Depth is a dial, not a marketing word.

The model never sees a tool that is not on this list. It is an allowlist, not a filter applied after the fact — an unlisted tool is invisible, which means the model cannot be talked into calling it. Set ROBINX_ALLOWED_TOOLS to narrow it further.

hoodpocket is a wallet server, and it is switched off on purpose. It is listed here rather than quietly deleted, because a fleet you are asked to trust should show you what it chose not to load.

{
  "mcpServers": {
    "your-stdio-server": {
      "command": "npx",
      "args": ["-y", "your-mcp-server@1.0.0"],

      // Only these env vars reach the child process. Not your whole environment.
      "envFrom": ["YOUR_API_KEY"],

      // Optional. Without it, state-changing tools are dropped automatically.
      "allowedTools": ["your_read_tool"]
    },

    "your-remote-server": {
      "url": "https://example.com/mcp",

      // "streamable-http" (or "http") | "sse". Omit it and we try streamable
      // HTTP first, then fall back to SSE.
      "transport": "streamable-http",

      // Header name -> the ENV VAR holding its value. Never the value itself:
      // this file is committed, and a token in a committed file is a leaked token.
      "headersFrom": { "Authorization": "YOUR_SERVER_TOKEN" }
    }
  }
}

ROBINX_ENGINE_KEY=...                 # all three turn live mode on together;
ROBINX_ENGINE_URL=<base URL>          # none has a default, so missing any one
ROBINX_ENGINE_MODEL=<model id>        # leaves the route on the demo agent
CHAT_TIMEOUT_MS=25000

ENGINE_USER_USD_PER_DAY=0.25          # the engine bills per token, so /api/chat
ENGINE_GLOBAL_USD_PER_DAY=5           # is metered — over a cap it returns 429

ROBINX_ALLOWED_TOOLS=robinx_verdict,robinx_token,robinx_deployer
ROBINX_WALLET_KEY=0x...               # optional — enables paid tools
ROBINX_MAX_USD_PER_CALL=0.10          # the ceiling on any single call

And when it breaks — a dead server, a timeout, a malformed reply — the response degrades to the demo agent rather than to a stack trace. The user gets a worse answer. Never a broken page.

Some RobinX tools are paid, settled in USDC over x402, mid-thought, without a human in the loop. The agent decides the forensics are worth ten cents and buys them. This is a small detail with a very large shadow: the moment an agent can pay for information, the price of an answer becomes a thing it can reason about — and the moment it can be paid, its answers become a thing other agents can buy.

We run the first half today. The second half — RobinX selling its verdicts to other agents, priced per call — is the machine economy this whole thing is pointed at, and it is in the research column below, where honest people put the things they have not built yet.

1. TodayLive

   Read — the chain, cross-examined

   Six RobinX tools and an external MCP fleet, planned across by the model and checked against each other. This ships, right now, in production. Everything below is built on it.

   Rug-check, deployer forensics, launch feed, leaderboard, holder spread, honeypot behaviour.

2. NextBuilding

   Forensics — the lies a chart cannot tell

   Holder clustering by funding path, bundler and sniper detection, wash-trade detection. Forty independent buyers who all took gas from one wallet six minutes before launch are not forty buyers — they are one entity wearing forty hats, and the first three blocks of a launch cannot lie about it.

   chain_holder_graph, chain_bundle_scan, chain_wash_scan

3. ThenPlanned

   Write — launch from one sentence

   "Launch MYTOKEN, 1B supply, LP locked 12 months, ownership renounced." The agent assembles the deploy, the pool, the lock, and the renounce into one reviewable bundle with verified source, simulates it, and hands it to your wallet. It never holds a key. It proposes; you sign.

   token_deploy, token_lp_seed, token_lp_lock, token_ownership

4. ThenPlanned

   Trade — close the loop

   Research and execution stop being two tabs. Quote the route, state the price impact, dry-run it against live chain state, show exactly what leaves the wallet — and only then offer it for signature. Nothing auto-fires.

   trade_quote, trade_simulate, trade_swap, trade_approvals

5. The betPlanned

   Standing agents — a prompt that outlives the tab

   "Watch this deployer. Wake me the second he launches again." The agent holds the watch after you close the laptop and pushes you the moment its condition trips. This is the line between a chatbot and something that works for you while you sleep.

   Persistent intents, push delivery, condition triggers.

6. The betPlanned

   RobinX MCP as a server anyone can call

   Flip the arrow. Today Bugglo is an MCP client that consumes tools. The prize is being the tool: point Claude Desktop, Cursor, or your own agent at RobinX MCP and call rug-check, deployer history, and chain state as primitives inside whatever you are building. Every agent that plugs in makes the chain more legible to every other one.

   Public MCP endpoint, scoped keys, per-tool metering.

7. ResearchResearch

   Execution behind a ceiling the agent cannot argue with

   "You may trade. You may not lose more than $200." An environment variable is not a guarantee — it is a suggestion enforced by the same process the agent runs in. A real ceiling is a number on-chain that the agent physically cannot exceed. That is a contract we have to write and have audited, and autonomous execution does not ship until it exists.

   Spend-cap vault. Audited, or not shipped.

8. ResearchResearch

   Agent pays agent

   x402 already lets the agent buy the premium forensics it needs mid-thought. Run it in reverse and RobinX sells its own verdicts to other agents, priced per call, settled in USDC. A machine economy where the unit of trade is a well-researched answer and the currency of reputation is being right in public.

   x402 in both directions, on-chain verdict history.

The through-line: every rung makes the one above it safer to climb. You do not get to let an agent trade until it can read a launch well enough to know it is a trap, and you do not get to let it trade unsupervised until the worst case is a number on-chain rather than a promise in a config file. That order is not caution. It is the only order that works.