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 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 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:

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:

# 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.

Related MCP server: meshledger-mcp-server

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.

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

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:

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

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

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 (see BANKR.md). Run it end to end:

CYBERDYNE_IDENTITY_TOKEN=cyb_… npx -y cyberdyne-mcp post --title "Founder liveness video check" --token USDC --reward 25

Install

Published on npm.

Fully autonomous (recommended) — no dashboard:

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:

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:

{
  "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:

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:

¹ 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

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.