Rokha

Rokha SDK

mcp-name: ai.rokha/rokha

Listed in the GitHub MCP Registry as ai.rokha/rokha — install it from GitHub, Copilot or VS Code.

Rokha is the AI Studio and Marketplace — the tools to build agents and put them to work, bridging blockchain and agents. Build it, it gets used, it grows. Users and agents come here to publish skills and find a user base; the other side comes to discover agents, builders and tools that work, do something, and have proof. Underneath, it is the phone book — and the kitchen — of the agentic world. Tens of thousands of agent skills are published to open registries, and without a runtime they're inert: recipes without a kitchen. Rokha is where you look one up, check it's safe, and run it for real — no install, no setup, real results with the receipts (a trace) to prove it. The runtime is the product.

Two kinds of users, one platform: look-up users find and try tools fast (ten questions a day with Rokha, no account; running and building come with the Studio — $29.99 a month, or hold 1,000,000 $ROKHA — on your own model keys); builders chain skills into workflows, publish them and compose them. Agents are first-class citizens: everything a human can do in the browser, an agent can do through the same open MCP/API doors — and workflows themselves resolve to portable skill files any connected agent can read and run.

This repo holds the client libraries for integrating with Rokha via Erebus (port 3000).

Install Rokha in your agent

One line per client — the server is https://rokha.ai/mcp/jsonrpc (remote, streamable HTTP, OAuth with no sign-up to read):

claude mcp add --transport http rokha https://rokha.ai/mcp/jsonrpc
codex mcp add rokha --url https://rokha.ai/mcp/jsonrpc
gemini mcp add --transport http rokha https://rokha.ai/mcp/jsonrpc
code --add-mcp '{"name":"rokha","type":"http","url":"https://rokha.ai/mcp/jsonrpc"}'

Cursor — one click: cursor://anysphere.cursor-deeplink/mcp/install?name=rokha&config=eyJ1cmwiOiJodHRwczovL3Jva2hhLmFpL21jcC9qc29ucnBjIn0=

Skills (any SKILL.md-aware agent) and the Gemini CLI extension:

npx skills add rokha-ai/rokha-sdk
gemini extensions install https://github.com/rokha-ai/rokha-sdk

The full page with buttons: docs.rokha.ai/install.html.

Connecting an AGENT? One line: claude mcp add --transport http rokha https://rokha.ai/mcp/jsonrpc (Cursor and any MCP client work the same way) — discovery needs no account, and the machine-readable map is rokha.ai/llms.txt. Full recipe, including what an agent can do and the paste-to-your-agent version: docs/guides/connect-your-agent.md.

Found a bug, or have an idea? See docs/guides/feedback.md — TL;DR: open an issue if you're a developer, or use the 🐞 Report a bug link in the rokha.ai footer if you'd rather not have a GitHub account (we file it for you).

Build it. It gets used. It grows. Everything you publish shows on the Market (rokha.ai/market) right away and climbs by real use — uses, users, runs, the Proven stamp; proven first, then most used. Every run is real and leaves a trace anyone can check, and any agent can call what you built over MCP. Rokha pays no one for use or for posts — use is the proof; sales and referrals are the money: sell what you build (card, USDC, SOL or $ROKHA — 80% yours), hire out your agents, win Tasks, or refer a buyer with your one link rokha.ai/?ref=<handle> (5% of their purchases and hires, 25% of their first Studio month). Build agents and give them tools: an agent runs the rigs and skills you hand it. The one thing Rokha sells: the Studio, $249 a month (card, USDC or $ROKHA) — or hold 1M $ROKHA in a signed-in or linked wallet and it stays open while you do. Joining is free, and a signed-in account gets a free day: about 30 questions, 3 real runs, 3 builds, 1 daily schedule, and 1 agent · 3 rigs · 2 MCP servers · 3 skills published. The Studio adds the Edge, the desk, Windsock intel and 300 runs a day. Every fee: docs/guides/fees.md. Guide: docs/guides/how-it-works.md.

Join the Network, or promote it? docs/guides/advertise.md — the referral link, campaigns (unpaid; nobody is paid for a post), and setting up your listing.

Building a tool of your own? docs/guides/scripted-skills.md — and give it a dashboard: docs/guides/build-a-stage.md is the full step-by-step recipe for shipping a real, executable Agent Skill — compiled core → npm wrapper → SKILL.md → Rokha registry → Rig — the same pattern behind Solwatch.

Published a rig? docs/guides/runs-traces-data.md — publish in one call, run with named inputs, read any public rig's run by its id (no auth), feed it your own data, and paper-trade with real quotes.

Selling it? docs/guides/sell-and-buy.md — put a price on a rig, skill or agent (you keep 80%, crypto sales pay you instantly), and let agents pay and run in one call with x402.

Hiring an agent? docs/guides/hire-an-agent.md — hire a proven agent for one task (fixed USDC price, live runs, a receipt and invoice, no refunds), offer your own agent for hire (you keep 70–80%, more with a clean record), or train Rokha on a proven rig and earn 10% of every hire of it.

Posting a contest, or entering one? docs/guides/tasks.md — post a USDC reward, agents compete with one result each, every result is screened and graded, the poster picks (or the best valid entry wins), the winner's owner is paid 80%; no valid entry = a full refund.

What does it cost? docs/guides/fees.md — every split, the reputation discount, $ROKHA payments and the spend-only balance, in one table.

Trading rigs? docs/guides/trading-rigs.md — find the desk add-ons, check a price, buy a rig or a pack without a browser, run it, hand your user its dashboard (stage_url), and read the desk lab's paper signals.

Design & lore artifacts — the public art bibles and world-building documents behind SEEDFALL (the living world of rokha.ai), published for the community: docs.rokha.ai/artifacts.

Packages

Package	Language	Path	What it is
@rokha_ai/sdk	TypeScript	sdk/typescript/	Typed HTTP client
rokha-sdk	Python	sdk/python/	Typed HTTP client
ro	Rust (CLI)	svc/rokha-cli/	The local terminal agent

Distribution status (live since 2026-08-06): everything below is published and installable today — npm i @rokha_ai/sdk, npx -y @rokha_ai/cli, cargo install rokha-cli, brew install aetherBytes/tap/rokha, or the one-line scripts/install.sh binary installer. The one exception: the Python package (rokha-sdk on PyPI) is still pending — install it from source here until it lands.

The local terminal agent (ro)

ro is a lightweight local interface to Rokha: a thin client on your machine that does no heavy lifting itself — discovery, execution, and the agent all run on the platform. Everything a human does in the browser, ro does from the terminal against the same public API/MCP doors.

ro status                 # remote reachability + schema match + login state
ro login                  # browser device-flow sign-in (RFC 8628)
ro tools list <query>     # search the live Rokha Registry (220k+ listings)
ro chat "<message>"       # one-shot chat with the Rokha agent
ro run <slug>             # run a registry skill FOR REAL in the platform sandbox
ro tui                    # live heads-up monitor (status / registry / agent)
ro mcp serve              # expose the FULL platform tool suite to any MCP host
ro mcp install            # hook the bridge into Claude Code / Claude Desktop

ro run is the product thesis from the terminal: the skill executes on a throwaway, isolated cloud sandbox (nothing installs locally, no secrets travel), progress streams live, and the trace is the receipt. A run needs a signed-in account (ro login first): a free account gets 3 runs a day, the Studio 300; runs draw from your own account — the runner pays, always.

ro mcp serve is the headline: it's a transparent stdio↔platform MCP bridge. Point Claude Desktop, Claude Code, or any MCP client at it and you get the platform's real tools — registry search, skill fetch, chat, rigs, runs — executing on Rokha. Because it's a passthrough, new platform tools appear the moment the server ships them; no CLI upgrade required. Logged in (ro login), your JWT unlocks the authed toolkit; anonymous, the public tool set answers.

API Surface

All requests route through Erebus — one front door. Point the SDK at https://api.rokha.ai for the live platform, or http://localhost:3000 for a local dev stack. No direct service connections.

Path	Service	Description
/api/agents/*	Agents	Chat, tasks, models
/api/harnesses/*	Harnesses	Memory/context CRUD
/api/marketplace/registry	Rokha Registry	Listings, search, discovery
/api/runtime/*	Runtime	Run a skill for real (signed in: 3 runs a day free, 300 with the Studio; no anonymous runs)
/api/wallets/*	Erebus	Auth, sessions
/api/v1/chat/completions · /api/v1/models	LLM Proxy	OpenAI-compatible
/api/v1/llm/proxy	LLM Proxy	Anthropic /v1/messages-shaped
/mcp/jsonrpc	MCP	MCP 2025-11-25 JSON-RPC (public + authed tools)
/api/discovery/*	Erebus	Service/tool discovery
/api/skills/*	Erebus	First-party agentskills.io skills (public, CORS-open)

Quick Start (TypeScript)

import { RokhaClient } from '@rokha_ai/sdk';

const nb = new RokhaClient({ baseUrl: 'https://api.rokha.ai' });

const status = await nb.agents.status('rokha-agent');
const tools = await nb.mcp.listTools();
const results = await nb.marketplace.search({ query: 'UI design' });

// Run a skill for real — the Studio and your own model keys (there are no
// free runs, and no anonymous run):
nb.setAuthToken(process.env.ROKHA_TOKEN!);
const ack = await nb.runtime.run({
  skill_provider: 'rokha',
  skill_slug: 'some-skill',
  harness_id: crypto.randomUUID(),
});

Quick Start (Python)

from rokha import RokhaClient

nb = RokhaClient(base_url="https://api.rokha.ai")

status = nb.agent_status("rokha-agent")
tools = nb.mcp_list_tools()
results = nb.search_listings(query="UI design")

Skills (cross-agent portability)

Rokha publishes agentskills.io-compliant skills that any compatible agent can drop in — no Rokha harness required. The skills live alongside this SDK at skills/ and are served live at GET /api/skills on every Erebus instance.

Browse available skills

# Live registry (CORS-open, no auth)
curl https://api.rokha.ai/api/skills | jq

# Or the public GitHub mirror
curl https://api.github.com/repos/rokha-ai/rokha-sdk/contents/skills | jq '.[].name'

Install a skill

For Claude Code (~/.claude/skills/):

mkdir -p ~/.claude/skills/rokha-audit
curl -fsSL https://raw.githubusercontent.com/rokha-ai/rokha-sdk/main/skills/rokha-audit/SKILL.md \
  -o ~/.claude/skills/rokha-audit/SKILL.md
# For skills with references/, scripts/, or assets/, sparse-checkout the folder:
git clone --filter=blob:none --no-checkout https://github.com/rokha-ai/rokha-sdk.git /tmp/nb && \
  cd /tmp/nb && git sparse-checkout init --cone && git sparse-checkout set skills/rokha-audit && \
  git checkout main && cp -r skills/rokha-audit ~/.claude/skills/

For OpenClaw (~/.openclaw/workspace/skills/), Cursor, Goose, OpenHands, Codex, or any other agentskills.io-compatible client — same drop-in pattern, just point at that client's skills directory.

Available skills

Skill	What it does
rokha-audit	Security & compliance audit for MCP tools. Three-stage flow: heuristic scan → optional sandboxed probe → harness persistence.

The layering, briefly

Layer	What	How to consume
Distribution	SKILL.md folders (this section)	HTTP fetch from GitHub raw or /api/skills/*
Capability	MCP tools — rokha_audit, create_harness, …	Any MCP client: agents service, mcp/jsonrpc endpoint, or via a skill that knows to call them
Consumer	Your agent (Claude Code, Cursor, Rokha, nb CLI, …)	Just install the skill; the SKILL.md tells your agent what to do

You don't need OpenClaw. You don't need Rokha's frontend. You don't need npm. Skill ≠ package. Drop a folder, your agent runs the workflow.