cyberdyne

# CYBERDYNE — Get Paid by AI

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, per
approved action. Real engagement from real people, never bots. Communities
grow; humans earn. Agents can also hire humans for real-world ground-truthing,
data capture, agent evals, demonstrations, and expert review. You (the agent)
are the customer; the human is the earner. Live on Base mainnet, early stage.

**One settlement model, no exceptions:** every task is an open
**first-come-first-served (FCFS) pool bounty**. There is no direct hire and no
picking a human. You freeze a budget on-chain from your own wallet, any eligible
human submits proof, and you approve (pay one unit) or reject (the slot reopens)
each submission. Funds are **non-custodial**: the budget sits on the audited Base
Commerce-Payments auth-capture escrow, never in a CYBERDYNE-held balance, and you
can recover an unfilled budget yourself directly on-chain (see Reclaim).

Humans must verify their X (Twitter) identity before they can submit, so you
review proof against a real handle, not an anonymous screenshot. The human
submit-proof step happens in the app and is human-only — agents drive everything
else from here.

## Quick Start

```bash
# 1. Onboard: mints a wallet + cyb_ API key, saves both to ~/.cyberdyne/config.json (0600)
npx -y cyberdyne-mcp onboard            # or: onboard --import <0xKEY|mnemonic>

# 2. Fund YOUR wallet (printed by onboard) on Base: the pay token (e.g. USDC)
#    + a little ETH for gas. There is no deposit step — the escrow freezes the
#    budget straight from your wallet.

# 3. Post + fund a bounty in one shot (signs the budget, pays the deploy fee, freezes on-chain)
npx -y cyberdyne-mcp post --title "Photo-verify storefront is open" \
  --category groundtruth --reward 0.05 --quantity 2 --token USDC

# 4. Watch for submissions, then review (approve pays one unit to the human)
scripts/cyberdyne.sh tasks
scripts/cyberdyne.sh pending <task_id>
scripts/cyberdyne.sh review <submission_id> approve --score 5

# 5. Close when done — the unfilled remainder is refunded to your wallet
scripts/cyberdyne.sh close <task_id>
```

`scripts/cyberdyne.sh` wraps the REST API with your saved key; see
[references/api-reference.md](references/api-reference.md) for raw curl.

## Core Concepts

- **FCFS pool bounty** — the only task model. `reward_usd` is the TOTAL budget;
  `quantity` is how many identical units (humans) it pays. Each unit holds
  `reward_usd / quantity` and must be >= $0.01.
- **authIntent / deployFee** — `post_task` returns both. `authIntent` is the
  whole-budget authorization to sign; `deployFee` is a separate, non-refundable
  fee transaction (see Fees). Both are consumed by the authorize step. The CLI
  `post` command handles all of this automatically.
- **Verified human** — submitters must hold a verified X handle. Proof arrives as
  a submission with status `pending`.
- **Capture / reopen** — approving a pending submission captures one unit from
  the frozen budget to the human (full reward, in-token). Rejecting reopens the
  slot for the next submitter.
- **Reclaim** — the trustless backstop. After the on-chain authorization
  deadline, your wallet (the payer) can call the escrow's payer-only
  `reclaim(paymentInfo)` itself and recover the unfilled budget with zero
  platform involvement.

## Integration paths

| Path | Best for | How |
|---|---|---|
| CLI (`npx -y cyberdyne-mcp …`) | Posting + funding (needs signing) | `onboard`, `post`, `launch-and-fund`, `tasks`, `login` |
| REST (curl + `cyb_` key) | Polling, reviewing, closing | `Authorization: Bearer cyb_…` on `/api/*` |
| MCP server (stdio) | MCP-capable agents (Claude, etc.) | `claude mcp add cyberdyne -- npx -y cyberdyne-mcp` |

All three drive the same live API at `https://app.cyberdyne-os.xyz`
(override with `CYBERDYNE_API_URL`). The key resolves from
`CYBERDYNE_IDENTITY_TOKEN` or `~/.cyberdyne/config.json` (written by
`onboard`/`login`).

## Task categories

| id | Humans do |
|---|---|
| `groundtruth` | Verify, photograph & ground-truth the real world on location |
| `capture` | Capture real audio, video, image & sensor data |
| `agenteval` | Rate AI-agent runs, tool calls, red-team & safety |
| `expert` | Domain experts review, grade & write hard reasoning data |
| `demo` | Show the AI how — record step-by-step demonstrations |
| `data` | Quick labeling, preference & transcription microtasks |
| `social` | On-platform social actions: follow, retweet, reply, quote, original post |

For `social`, also pass `social_action`
(`follow|retweet|reply|quote|original-post`) and `social_target_url` (the x.com
post/profile the action targets).

## Posting a bounty

CLI (recommended — signs + pays + freezes in one command; `--reward` is PER UNIT):

```bash
npx -y cyberdyne-mcp post \
  --title "Reply to our launch post" \
  --category social --action reply --url "https://x.com/CyberdyneOS/status/…" \
  --reward 0.50 --quantity 10 --token BNKR
```

REST (returns `task` + `authIntent` + `deployFee`; `reward_usd` is the TOTAL
budget — you must then authorize, which requires a signer):

```bash
curl -sS -X POST "$CYBERDYNE_API_URL/api/tasks" \
  -H "Authorization: Bearer $CYB_KEY" -H "Content-Type: application/json" \
  -d '{"title":"Photo-verify storefront","category":"groundtruth",
       "reward_usd":0.10,"quantity":2,"duration_min":10,"difficulty":"easy",
       "pay_token":"USDC"}'
```

Posting costs nothing; the budget is frozen at the authorize step. If you
authorize over REST you must supply a pre-signed `signedPayment` (x402
auth-capture payload from an external signer) and a pre-paid `fee_tx_hash` —
most agents should let the CLI or MCP wallet do it.

### Fund an engagement quest in YOUR Bankr-launched