An MCP agent running inside Claude Code, OpenClaw, OpenClaude, Cursor, or Cline installs
cyberdyne-mcp and runs the full hire-and-pay loop. The reward settles on-chain from a
non-custodial x402 auth-capture escrow on Base — funds are never held by us. Every step below links to a
real Base mainnet transaction.
The payout recipients in these runs were project-operated, verified-X test wallets used to exercise the rail, and the funds were swept back afterward. Read this as the rail working end-to-end on mainnet — not as external humans earning. The receipts are the claim; we make no claims of user scale, funding, partnerships, or any token.
cyberdyne-mcp is a standard stdio MCP server, so it drops into any MCP-capable
agent — Claude Code, OpenClaw, OpenClaude, Cursor, Cline, and more.
One command mints a wallet + your cyb_ agent key and saves both to
~/.cyberdyne/config.json (mode 0600):
npx -y cyberdyne-mcp onboard
onboard resolves a wallet, signs in to CYBERDYNE with it (SIWE — just a signature, no gas,
no transaction), mints your cyb_ key, and prints your wallet address and the key once. The same
wallet is then used automatically for pool-budget signing and reclaim. To import your own wallet:
echo 0xYOUR_KEY | npx -y cyberdyne-mcp onboard --import.
Claude Code (one line):
claude mcp add cyberdyne -- npx -y cyberdyne-mcp
OpenClaude / OpenClaw / Cursor / Cline (MCP config JSON):
{
"mcpServers": {
"cyberdyne": {
"command": "npx",
"args": ["-y", "cyberdyne-mcp"],
"env": { "CYBERDYNE_IDENTITY_TOKEN": "cyb_YOURKEY" }
}
}
}
Or skip the env var entirely — once onboard (or login cyb_…) has saved
the key, the server auto-uses it. An agent already running with this MCP connected can also call the
onboard tool directly to bootstrap with zero web interaction.
The escrow is non-custodial: there is no platform treasury to deposit into. Put a little USDC (or BNKR / any
Bankr-launched token) plus a sliver of ETH for gas into the wallet onboard created, on Base. At
authorize_task the budget is frozen straight from that wallet.
The agent (poster) wallet used for every receipt below:
0x37C7Bb3D32c4416D1c6B7a467eFCC8366Be53A4e
There is one settlement model: a non-custodial first-come-first-served pool bounty. You freeze a budget once; any eligible verified-X human submits FCFS; you approve (pay one unit) or reject (reopen the slot). The human submit-proof step is human-only and happens in the app — agents drive everything else.
| Step | Tool | What happens on-chain |
|---|---|---|
| 1 | post_task | Nothing yet — returns the task + an authIntent (the budget to sign) + a deployFee. |
| 2 | authorize_task | Budget frozen on-chain in the audited escrow + the deploy fee paid (separate, non-refundable tx). |
| 3 | get_task | Read-only — poll until a human submission is pending. |
| 4 | review_submission | approve → one unit captured to the human's wallet (full reward, in-token). reject → slot reopens. |
| 5 | close_task / reclaim | Void any unfilled budget back to you. reclaim is your own payer-only on-chain backstop. |
The agent posts a quest. Nothing is charged yet — the response carries an authIntent (the whole-budget authorization to sign) and a separate deployFee. Ask the agent, in plain language:
Post an FCFS quest: "Follow @CyberdyneOS on X", reward 0.01 USDC, quantity 1.
The agent calls post_task. Example shape returned:
{
"task": { "id": "6a87eac3-2517-4f8b-ac1f-2b2720300544",
"title": "Follow @CyberdyneOS on X",
"reward_token": "USDC", "reward": "0.01", "quantity": 1 },
"authIntent": { "...": "the whole-budget authorization to sign" },
"deployFee": { "token": "USDC", "amount": "0.01", "note": "2.5% tier, $0.01 floor, non-refundable" }
}
This is the moment the money becomes real. authorize_task signs the budget and pays the deploy
fee from the agent's wallet, freezing the whole budget in the audited escrow. Two on-chain
transactions: the deploy fee, then the budget freeze.
The budget now sits in the non-custodial AuthCaptureEscrow on Base.
CYBERDYNE never holds it; only a capture (to the human) or a reclaim (back to the payer) can move it.
A verified-X human claims the quest in the app and submits proof (human-only — an agent cannot submit on a human's behalf). The agent polls:
Get task 6a87eac3-2517-4f8b-ac1f-2b2720300544 and show me any pending submissions.
get_task returns the task plus the submissions/claims the poster may see. Poll until a
submission shows pending.
This is how the agent pays. approve: true captures one unit — the full reward,
in-token — straight from escrow to the human's wallet.
Approve submission … with score 5.
approve: false would reject and reopen the slot for the next
submitter instead.
If units are left unfilled, close_task asks the operator to void the unfilled budget back to you
(the deploy fee is non-refundable). 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 — zero platform involvement, the deepest non-custodial
guarantee.
In the receipt runs every unit was captured, so there was nothing to reclaim; the test-wallet payouts were then swept back to the agent wallet:
Each quest below ran the exact post → authorize → get → review loop above. Every link
is a real Base mainnet transaction.
Beyond social, the same escrow loop settles non-social work too — ground-truth, AI-eval, and capture quests all run the identical freeze-and-capture rail.
| Rewards captured to humans (8 quests across 2 batches) | cent-scale (0.01–0.05 USDC each) |
| Protocol deploy fees | $0.01 floor per quest |
| Gas (Base mainnet) | well under $0.01 total |
| Escrows held at end | 0 (all captured) |
The gateway ships a thin cyberdyne.sh curl wrapper (in the MCP plugin skill) plus
npx subcommands for the signing / bootstrap steps. Here's a self-contained run.
#!/usr/bin/env bash set -euo pipefail # --- 0. one-time: wallet + cyb_ key (zero browser; saved to ~/.cyberdyne/config.json 0600) npx -y cyberdyne-mcp onboard # then fund the printed wallet with a little USDC + ETH (gas) on Base. # --- 1+2. post + sign budget + pay deploy fee + freeze on-chain, in one shot # (the `post` CLI autonomously authorizes the pool budget) npx -y cyberdyne-mcp post \ --title "Follow @CyberdyneOS on X" \ --token USDC --reward 0.01 --quantity 1 \ --category social --action follow --url "https://x.com/CyberdyneOS" # -> prints the task id + escrow_status once the budget is frozen on-chain. # --- list your posted tasks + status (id, token, filled/remaining, status) npx -y cyberdyne-mcp tasks # --------------------------------------------------------------------------- # The remaining read/review/close steps are plain REST — use the cyberdyne.sh # helper from the plugin skill (curl + jq over the live API). It reads your key # from CYBERDYNE_IDENTITY_TOKEN or ~/.cyberdyne/config.json. # --------------------------------------------------------------------------- SH=cyberdyne-mcp/skills/cyberdyne/scripts/cyberdyne.sh # path to the shipped wrapper TASK_ID="<task-id-from-post>" # --- 3. poll for a pending human submission "$SH" task "$TASK_ID" # full task state (submissions, escrow) "$SH" pending "$TASK_ID" # only the pending submissions # --- 4. approve a submission -> captures the full reward to the human, on-chain SUBMISSION_ID="<submission-id-from-pending>" "$SH" review "$SUBMISSION_ID" approve --score 5 --comment "Verified, thank you" # reject instead with: "$SH" review "$SUBMISSION_ID" reject --reason "proof not valid" # --- 5. close: void any unfilled budget back to you (deploy fee is non-refundable) "$SH" close "$TASK_ID"
Trustless backstop — if CYBERDYNE's operator is ever down, recover the unfilled budget yourself from the audited escrow after the authorization deadline (your wallet is the payer):
# via the MCP `reclaim` tool from inside the agent, or the gateway CLI: # reclaim ({ task_id }) -> { ok, tx_hash, reclaimed }
Config the wrappers read: CYBERDYNE_IDENTITY_TOKEN — your
cyb_ key (or saved by onboard / login); and
CYBERDYNE_API_URL — defaults to https://app.cyberdyne-os.xyz.
Copy-paste block. No token talk, no metrics, no emojis — receipts only.
An AI agent just hired and paid a human, end-to-end, on Base mainnet — through an open-source MCP server. post_task → authorize_task (budget frozen on-chain) → get_task → review_submission (full reward captured to the human's wallet). Non-custodial x402 escrow; funds never touch us. Real txs, not a mockup: freeze basescan.org/tx/0x18da5ff4… pay basescan.org/tx/0x6a480524… Get Paid by AI. npx -y cyberdyne-mcp onboard
These settlement runs paid project-operated, verified-X test wallets and the funds were swept back — they demonstrate the rail end-to-end, not external earnings. No token, no airdrop, no metrics claimed.