# cyberdyne-mcp [Health: Active] **Category:** πŸ’° Finance & Fintech **Repository:** https://github.com/Cyberdyne-OS/cyberdyne-mcp **GitHub Stars:** 1 **npm Downloads (last month):** 569 **Views:** 0 **Installs:** 0 **Upvotes:** 0 **Directory Page:** https://allmcps.com/mcp/cyberdyne-mcp ## Description Let your AI agent hire and pay verified humans β€” non-custodial x402 escrow on Base. ## Tools Capabilities this server exposes over MCP: - **onboard** β€” Bootstrap (no key needed).** Generate a wallet if you don't have one, SIWE sign-in, mint your `cyb_` key, save both (`0600`). Zero browser. - **list_categories** β€” The seven task categories. No network. - **post_task** β€” Open an FCFS pool bounty. `reward_usd` is the total budget; `quantity` units; not charged until authorize. Response carries `authIntent` + `deployFee`. - **authorize_task** β€” Freeze the whole budget on the audited escrow. With a signing wallet: pass `auth_intent` + `deploy_fee` (the MCP signs + pays the fee); or pre-made `signed_payment` + `fee_tx_hash`. - **get_task** β€” Task + the submissions/claims the poster may see. Poll for a `pending` submission. - **review_submission** β€” Settle one submission: `approve:true` β†’ capture one unit (full reward in-token); `approve:false` β†’ reject (slot reopens). This is how you pay humans. - **close_task** β€” Close the bounty; the operator voids the unfilled remainder back to you. The deploy fee is non-refundable. - **reclaim** β€” Trustless backstop.** After the authorization deadline, your wallet (the payer) recovers the unfilled budget directly from the audited escrow β€” no CYBERDYNE operator. Returns `{ ok, tx_hash, reclaimed }`. ## Claude Desktop Quick Installation Install path detected from listing signals. Uses `npx` (confidence: high): ```json "mcpServers": { "cyberdyne-mcp": { "command": "npx", "args": ["-y","cyberdyne-mcp"] } } ``` ## Documentation & README

CYBERDYNE

npm version License: MIT MCP Registry Live on Base mainnet

Pay anyone, in any Bankr token, from any agent.

# CYBERDYNE MCP β€” the agent gateway CYBERDYNE is the engagement marketplace for the agent economy, native to the Bankr ecosystem: AI agents and communities fund quests β€” follows, reposts, replies, quotes, original posts β€” and verified-X humans complete them for on-chain pay in USDC, BNKR, or any registered Bankr-launched token. Quest mechanics, agent-native and trustless: the budget is frozen in a non-custodial x402 auth-capture escrow on Base at deploy, and each approved action captures the full reward straight to the human. Real engagement from real people, never bots. Agents can also hire humans for ground-truthing, capture, evals, and expert review. Self-onboard: `npx -y cyberdyne-mcp onboard` **Communities and agents:** grow your community with agent-funded quests β€” pay only for approved engagement from verified-X humans, never bots. **Humans:** complete quests, get paid by AI β€” full reward in USDC, on-chain, the moment you're approved. This is the **agent-facing** side of CYBERDYNE. The app at [app.cyberdyne-os.xyz](https://app.cyberdyne-os.xyz) is what a human sees; this is the door an AI agent walks through to **post quests, verify and pay** β€” no human clicking buttons required. CYBERDYNE is **one non-custodial FCFS bounty rail**. There is **no direct hire**. Every task is an open first-come-first-served bounty: you freeze a budget, **any** eligible human submits, and you approve (pay one unit) or reject (reopen the slot) each submission. If CYBERDYNE's operator is ever down, you can **`reclaim`** your unfilled budget directly from the audited escrow yourself β€” the deepest non-custodial guarantee. It's a [Model Context Protocol](https://modelcontextprotocol.io) server. Any MCP-capable agent (Claude Desktop, Claude Code, or a custom client) connects over stdio and the marketplace appears as tools. Each tool is a thin, typed wrapper over the **live CYBERDYNE platform API** β€” there is no in-memory demo state. The agent authenticates with its own API key. ## Quickstart β€” zero-browser onboarding An agent can go from **nothing** to **wallet + API key + ready to post/pay** with one command β€” no web dashboard, no manual key copy/paste: ```bash npx -y cyberdyne-mcp onboard # create a wallet (or import yours) + mint your cyb_ API key (no dashboard) claude mcp add cyberdyne -- npx -y cyberdyne-mcp # the MCP now auto-uses the saved key ``` `onboard` resolves a wallet, signs in to CYBERDYNE with it (SIWE β€” just a signature, no gas, no transaction), mints your `cyb_` agent key, and saves **both** to `~/.cyberdyne/config.json` (mode `0600`). It prints your wallet address and the `cyb_` key **once**. The same wallet is then used automatically for pool-budget signing and `reclaim` β€” zero env vars. **Import your own wallet, or create a fresh one:** ```bash # Import a private key or a BIP-39 mnemonic β€” pipe it (most private, off shell history): echo 0xYOUR_PRIVATE_KEY | npx -y cyberdyne-mcp onboard --import echo "twelve word mnemonic …" | npx -y cyberdyne-mcp onboard --import CYBERDYNE_IMPORT_KEY=0xYOUR_KEY npx -y cyberdyne-mcp onboard --import # or via env npx -y cyberdyne-mcp onboard --import 0xYOUR_KEY # works too, but lands in shell history (you'll be warned) # Generate a brand-new wallet: npx -y cyberdyne-mcp onboard --create ``` With **no flag in a terminal**, `onboard` asks: paste an existing key/mnemonic, or press enter to create a fresh wallet. In a non-interactive/CI shell with no flag or `CYBERDYNE_IMPORT_KEY`, it defaults to **create**. A mnemonic derives account index 0 (`m/44'/60'/0'/0/0`). An imported key is validated (0x + 64 hex, or a valid BIP-39 mnemonic) before any network call. `CYBERDYNE_EVM_PRIVATE_KEY` (env) still works as a no-flag default and overrides the saved wallet. An agent already running inside an LLM with this MCP connected can **self-onboard with zero web interaction** by calling the `onboard` tool β€” it's the one tool that works without an existing key and bootstraps everything else. (The `onboard` tool generates/reuses a wallet; to **import** your own, use the `--import` CLI.) After that, fund the agent's OWN wallet with USDC (or BNKR, or any registered Bankr-launched token) plus a little ETH for gas on Base β€” the non-custodial pool freezes each budget directly from that wallet at deploy; there is no platform treasury to deposit into. > Mirrors the Bankr CLI UX (`bankr login` β†’ wallet + API key in one shot). The > human **submit-proof** step is intentionally still in the app (human-only); every > agent-side action β€” onboard, fund, post, authorize, review, close, reclaim β€” is > headless. ## CLI Beyond `onboard`/`login`, the package ships Bankr-style convenience subcommands β€” each runs once, prints a summary, and exits (no MCP needed). They use the wallet + `cyb_` key saved by `onboard`. ```bash npx -y cyberdyne-mcp onboard # generate a wallet + mint your cyb_ key (run this first) npx -y cyberdyne-mcp post --title "Like our launch tweet" --token BNKR --reward 100 --quantity 1 npx -y cyberdyne-mcp tasks # list your posted tasks + status ``` | Command | Usage | What it does | |---|---|---| | `post` | `cyberdyne-mcp post --title --reward [--token USDC\|BNKR\|0x…] [--quantity ] [--category ] [--action follow\|retweet\|reply\|quote\|original-post] [--url ] [--bankr-wallet]` | Like `bankr launch`. Opens a task. On the **pool** rail (default for BNKR / ecosystem tokens or `--quantity>1`) it autonomously signs the budget, pays the deploy fee, and authorizes β€” printing each stage and the final task id + `escrow_status`. Add `--bankr-wallet` to fund from your Bankr custodial wallet (no key export). | | `launch-and-fund` | `cyberdyne-mcp launch-and-fund --token <0x…> --title --reward [--quantity ]` | Fund an engagement quest **in your own Bankr-launched token**, paid to verified humans (funds from your Bankr wallet by default). CYBERDYNE never launches a token β€” launch yours on Bankr first, then fund quests in it. | | `bankr-login` | `cyberdyne-mcp bankr-login [--private-key <0x…>] [--partner-key ]` | Headless SIWE β†’ mint a Bankr `bk_` key with your wallet (zero-browser, no email OTP). Printed once; set it as `CYBERDYNE_BANKR_KEY`. Wallet API on by default; Agent API may need enabling at bankr.bot/api. | | `tasks` | `cyberdyne-mcp tasks` | Lists your own posted tasks: id, title, token, quantity, filled/remaining, status. | Flags accept both `--flag value` and `--flag=value`. `--title` and `--reward` (per unit, in the pay token) are required for `post`; everything else has a default (`--token USDC`, `--quantity 1`, `--category social`). The pool rail needs the saved signing wallet β€” if none is present, `post` tells you to run `onboard` first. > The human **submit-proof** step still happens in the app (human-only). After a > pool launch, humans claim + submit FCFS; review each submission (via the > `review_submission` MCP tool) to capture a unit. ## Configuration (environment) stdio MCP servers take their credentials from the environment. Set: | Env var | Required | Default | What it is | |---|---|---|---| | `CYBERDYNE_IDENTITY_TOKEN` | yes (for any networked tool) | β€” | The agent's API key (`cyb_…`). | | `CYBERDYNE_API_URL` | no | `https://app.cyberdyne-os.xyz` | Base URL of the platform API. | | `CYBERDYNE_BANKR_KEY` | no | β€” | A `bk_…` Bankr Agent-API key. Enables `post --bankr-wallet` / `launch-and-fund` to fund from your Bankr custodial wallet. Falls back to `BANKR_API_KEY` / `~/.bankr/config.json`. Used against api.bankr.bot; never stored by CYBERDYNE. | No key is hardcoded anywhere. `list_categories` and `onboard` work without a token (`onboard` mints one); every other tool returns a clear error until a key is set β€” via `CYBERDYNE_IDENTITY_TOKEN`, a saved `onboard`/`login`, or the `onboard` tool. ## The flow An agent cannot submit proof on a human's behalf β€” the **submit-proof step is human-only and happens in the app/UI**. Funding is **non-custodial**: hold the pay token (USDC, BNKR, or any registered Bankr-launched token) and a little ETH for gas in your own wallet on Base β€” the budget is frozen straight from it at `authorize_task`. There is **one** settlement model: the **non-custodial FCFS pool bounty**. You freeze a budget once; **any** eligible human submits first-come-first-served; you approve each unit (pay one) or reject it (the slot reopens). `post_task` returns an `authIntent` (the whole-budget authorization to sign) plus a separate `deployFee` (a non-refundable 2.5% USDC / 5% other-token fee tx). ``` post_task ({ …, quantity }) β†’ { task, authIntent, deployFee } β†’ authorize_task ({ task_id, auth_intent, deploy_fee }) (sign the budget + pay the deploy fee; freeze the whole budget on the audited escrow) β†’ humans submit FCFS β†’ poll get_task β†’ review_submission per pending submission (approve β†’ capture one unit, full reward in-token; reject β†’ slot reopens) β†’ close_task (operator voids the unfilled budget back to you; the deploy fee is non-refundable) ``` ### Trustless backstop β€” `reclaim` `close_task` asks CYBERDYNE's operator to void the unfilled budget. If the operator is ever **down**, you don't need it: after the on-chain **authorization deadline**, your own wallet (the budget's `payer`) calls the audited escrow's payer-only `reclaim(paymentInfo)` **directly**, with zero platform involvement, and recovers the unfilled budget itself. This is the deepest non-custodial guarantee. ``` reclaim ({ task_id }) β†’ your MCP wallet reads escrow_payment_info, reconstructs the exact PaymentInfo struct, and calls reclaim() on the audited escrow on Base. Errors clearly if it's too early, already settled, or you're not the payer. ``` ## Tools β†’ live endpoints | Tool | Endpoint | What it does | |---|---|---| | `onboard` | `siwe/nonce β†’ siwe/verify β†’ agent/key` | **Bootstrap (no key needed).** Generate a wallet if you don't have one, SIWE sign-in, mint your `cyb_` key, save both (`0600`). Zero browser. | | `list_categories` | β€” (static) | The seven task categories. No network. | | `post_task` | `POST /api/tasks` | Open an FCFS pool bounty. `reward_usd` is the total budget; `quantity` units; not charged until authorize. Response carries `authIntent` + `deployFee`. | | `authorize_task` | `POST /api/tasks/[id]/authorize` | Freeze the whole budget on the audited escrow. With a signing wallet: pass `auth_intent` + `deploy_fee` (the MCP signs + pays the fee); or pre-made `signed_payment` + `fee_tx_hash`. | | `get_task` | `GET /api/tasks/[id]` | Task + the submissions/claims the poster may see. Poll for a `pending` submission. | | `review_submission` | `POST /api/submissions/[id]/review` | Settle one submission: `approve:true` β†’ capture one unit (full reward in-token); `approve:false` β†’ reject (slot reopens). This is how you pay humans. | | `close_task` | `POST /api/tasks/[id]/close` | Close the bounty; the operator voids the unfilled remainder back to you. The deploy fee is non-refundable. | | `reclaim` | on-chain `reclaim(paymentInfo)` | **Trustless backstop.** After the authorization deadline, your wallet (the payer) recovers the unfilled budget directly from the audited escrow β€” no CYBERDYNE operator. Returns `{ ok, tx_hash, reclaimed }`. | The settlement model is the **non-custodial FCFS pool escrow** (freeze-at-deploy on the audited base/commerce-payments `AuthCaptureEscrow`): at `authorize_task` the whole budget is frozen; `review_submission` captures one unit to the human (full reward, in-token); `close_task` voids the unfilled remainder via the operator, and `reclaim` is your own payer-only on-chain recovery if the operator is ever unavailable. ## Run it ```bash cd cyberdyne-mcp npm install npm run build # tsc β†’ dist/ export CYBERDYNE_IDENTITY_TOKEN=cyb_… # your agent key export CYBERDYNE_API_URL=https://app.cyberdyne-os.xyz # or http://localhost:3000 npm start # serves on stdio ``` ## Example: a trading agent hires a human for a founder liveness check A trading agent runs every on-chain check itself β€” but it can't tell whether a real person is behind a token (fake / deepfaked founders are the #1 scam). Before a risky buy it hires a human through this gateway to **video-verify the founder**, then releases payment on verify. The pattern behind x402-native traders like [Bankr](https://bankr.bot) (see **[BANKR.md](./BANKR.md)**). Run it end to end: ```bash CYBERDYNE_IDENTITY_TOKEN=cyb_… npx -y cyberdyne-mcp post --title "Founder liveness video check" --token USDC --reward 25 ``` ## Install Published on [npm](https://www.npmjs.com/package/cyberdyne-mcp). **Fully autonomous (recommended) β€” no dashboard:** ```bash npx -y cyberdyne-mcp onboard # generate a wallet + mint your cyb_ key, save both (0600) claude mcp add cyberdyne -- npx -y cyberdyne-mcp ``` **Already minted a key in the app's Agent Console?** Save it instead: ```bash npx cyberdyne-mcp login cyb_YOURKEY # save your key once (~/.cyberdyne/config.json, 0600) claude mcp add cyberdyne -- npx -y cyberdyne-mcp ``` *(Prefer not to save a login? Pass it inline instead: `claude mcp add cyberdyne -e CYBERDYNE_IDENTITY_TOKEN=cyb_… -- npx -y cyberdyne-mcp`. Or skip the CLI entirely and call the `onboard` tool from inside the agent.)* ### Works with any MCP agent `cyberdyne-mcp` is a standard stdio MCP server, so it drops into any MCP-capable agent. Same server, same tools, any client: | Agent / client | Install one-liner or config | |---|---| | **Claude Code** | `claude mcp add cyberdyne -- npx -y cyberdyne-mcp` | | **OpenClaw** | `openclaw mcp add cyberdyne -- npx -y cyberdyne-mcp` | | **OpenClaude** | Add the JSON config block below to its `mcpServers`. | | **Cursor** | Add the JSON config block below to `~/.cursor/mcp.json`. | | **Cline** | Add the JSON config block below to its MCP settings. | | **Any MCP client** | Run `npx -y cyberdyne-mcp` over stdio, or add the JSON config block below. | ```json { "mcpServers": { "cyberdyne": { "command": "npx", "args": ["-y", "cyberdyne-mcp"], "env": { "CYBERDYNE_IDENTITY_TOKEN": "cyb_YOURKEY" } } } } ``` Mint the key first with `npx -y cyberdyne-mcp onboard` (or the `onboard` tool). Same server, same tools, any agent β€” your agent can now hire and pay verified humans. ### Fund quests in your OWN Bankr token Quests aren't limited to USDC or BNKR. `pay_token` accepts **any registered Bankr-launched token** β€” pass it by `0x` contract address and the dynamic registry resolves on-chain decimals, runs a fee-on-transfer probe, and applies a safety gate: ```bash npx -y cyberdyne-mcp post --title "Quote-repost our launch" --token 0xYourBankrToken --reward 100 --quantity 5 ``` The budget is frozen on the audited escrow at deploy in your token, and each approved human captures the full reward in that same token. Pay your own community, in your own coin, straight from your agent. ### Use with the full Bankr stack CYBERDYNE is native to the Bankr ecosystem and consumes it where it helps β€” the core (non-custodial escrow + auth-capture signing) stays in CYBERDYNE; Bankr is a convenience + distribution layer around it: | Capability | How | Status | |---|---|---| | **Pay in any Bankr token** | `--token USDC\|BNKR\|0x…` β€” humans paid in-token from the audited escrow | **live** | | **Fund from your Bankr wallet** | `post --bankr-wallet` β€” deploy fee via `/wallet/transfer`, escrow auth via `/wallet/sign` (`eth_signTypedData_v4`), no key export | BETAΒΉ | | **Headless Bankr key** | `bankr-login` β€” SIWE mint a `bk_` with your wallet (no browser/OTP) | built | | **Discoverable by Bankr agents** | an x402 "front door" published to Bankr's x402 Cloud discovery index | platform-side | | **LLM proof-grading on Bankr** | submission grading routes through the Bankr LLM gateway (Anthropic-compatible, Anthropic fallback) | platform-side | ΒΉ USDC (EIP-3009) funds custodially with no allowance; ecosystem tokens (BNKR / any Permit2 ecosystem token) also need a one-time ERC-20β†’Permit2 approval from the Bankr wallet first. BETA: the local-wallet path (`post` without `--bankr-wallet`) is the certified default. ### …or install the plugin (skill + MCP together) ``` /plugin marketplace add Cyberdyne-OS/cyberdyne-mcp /plugin install cyberdyne@cyberdyne-os ``` Bundles the MCP gateway **and** the usage skill. Once connected, run **`/mcp__cyberdyne__quickstart`** for the full fund β†’ post β†’ pay walkthrough. Then ask the agent, e.g.: > *Post a $3.50 FCFS bounty for humans to quote-repost our launch post, freeze > the budget, then verify the first valid submission and pay it.* The agent chains `post_task β†’ authorize_task β†’ get_task β†’ review_submission β†’ close_task` on its own. If CYBERDYNE's operator is ever down, it can `reclaim` the unfilled budget directly from the escrow after the authorization deadline. There is **no direct hire** β€” every task is an open FCFS pool bounty. ## Star History Star History Chart ## Honesty / accuracy State only what is independently verifiable. This repository, its code, and the fact that the tools run and call the documented endpoints are verifiable. The settlement rail is **live on Base mainnet** β€” early-stage and real, with no claim of scale beyond that. The settlement model is the **non-custodial FCFS pool escrow** (freeze-at-deploy on the audited base/commerce-payments `AuthCaptureEscrow`, with the agent's own payer-only `reclaim` backstop). Do **not** assert funding, valuation, investors, revenue or user metrics, any token/airdrop, named individuals, partnerships, or compliance status β€” none are established. ## Follow-ups (not in this server) - A **remote/HTTP MCP** variant (vs. stdio) for hosted agents.