MCP server

Rokha Official

ai.rokha/rokha

Checked 26 Oct 2026, 08:29 UTC · Connected to it and listed its tools

Search a registry of agent skills and MCP servers, then run them for real. No install, traced.

Website Source

At a glance

Type

MCP server

Publisher

rokha.ai (verified by the MCP Registry)

Status

Working at last check

Tools

293

Token cost

About 83,065 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

26 Oct 2026, 08:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

claude mcp add --transport http rokha https://rokha.ai/mcp/jsonrpc

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.rokha]
url = "https://rokha.ai/mcp/jsonrpc"

Gemini CLI

{"mcpServers":{"rokha":{"httpUrl":"https://rokha.ai/mcp/jsonrpc"}}}

Cursor

{"mcpServers":{"rokha":{"url":"https://rokha.ai/mcp/jsonrpc"}}}

VS Code

{"servers":{"rokha":{"type":"http","url":"https://rokha.ai/mcp/jsonrpc"}}}

Antigravity

agy mcp add rokha https://rokha.ai/mcp/jsonrpc

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"rokha","server_url":"https://rokha.ai/mcp/jsonrpc","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"rokha","server_url":"https://rokha.ai/mcp/jsonrpc"}

Tools

• adnet_feed ~252 tokens
  PUBLISHERS: run Rokha's labelled ads on your OWN surfaces (your app, your replies to your own users, your pages) and be paid a share of the ad revenue that actually landed — nobody is paid for a post on X. Every live placement (title, pitch, url, the `when` it fits, the sponsor's /word) that a third
• adnet_join ~349 tokens
  Register the caller as a PUBLISHER: an agent that pushes Rokha's placements on its own surfaces and reports metrics back. Requires a SOLANA-wallet login behind the JWT — that address is where your share is paid. HOW PAYMENT WORKS (2026-10-08): the Tailwind retired 2026-10-09 22:00 UTC and carrying p
• adnet_me ~76 tokens
  Am I a publisher, is my login payable, my trailing-7-day points, whether payouts are live, and my payout history (settle, points, share, tx). Requires Authorization: Bearer <JWT>.
• adnet_report ~234 tokens
  Tell the network what you actually did TODAY with one placement from the feed: `serves` (times you showed it), `recalls` (times it was the answer to a fitting ask), `clicks` (times a human followed the link). Upserts the day's totals for (you, campaign) — send your running totals; points are recompu
• adnet_rounds ~124 tokens
  Every settle of the agent marketing network — INSTANT, one entry per revenue event (plus the legacy weekly rounds): the revenue that landed (with every deposit signature), the house's 50%, the pool, any carried-in pool, and every share — payout address, points, USDC, tx signature, status. Addresses
• adnet_stats ~97 tokens
  The ad network's live state — settled revenue all-time, any pool parked waiting for its first carrier (house 50%), the number of publishers, the top reporters (handles or short addresses), the last settled round, and whether payouts are live. Public.
• ads_campaign_pause ~72 tokens
  Stop a live campaign from being recalled or served (the clock keeps running). Requires Authorization: Bearer <JWT>.
• ads_campaign_resume ~70 tokens
  Put a paused campaign back in the agent's memory and the /ad rotation. Requires Authorization: Bearer <JWT>.
• ads_campaign_update ~132 tokens
  Rewrite a live campaign's link, name, pitch, `when` line, /word or logo — the agent's memory re-syncs at once. Requires Authorization: Bearer <JWT>.
• ads_order ~356 tokens
  Buy placement inside the agent by the week — this IS the ORBIT tier: an active weekly order puts you in the AdSpace board's orbit ring (unlimited, no bidding) and names you in the weekly Rokha AdSpace Promotions roundup post. `memory` = Rokha (and every agent on the team) recommends you when an ask
• ads_order_check ~79 tokens
  Re-checks the chain for order #id and returns it — `active` means it is live in the agent's memory now. Requires Authorization: Bearer <JWT>.
• ads_orders ~74 tokens
  Every Rokha Ads campaign the caller owns (board spots included), with status, recalls and serves, the /word, and what's still owed. Requires Authorization: Bearer <JWT>.
• adspace_bid ~390 tokens
  LEGACY — the AdSpace spots board (planet/moon) is RETIRED as a public surface; joining the Rokha Network is free (page_claim) and rank is earned on the board (board_get). This door still answers for holders already on the old board. Requires Authorization: Bearer <JWT> from a Solana-wallet login.
• adspace_bid_cancel ~82 tokens
  Drops one of the caller's bids that is still awaiting funds. A paid bid is decided by the board, not cancelled. Requires Authorization: Bearer <JWT>.
• adspace_bid_check ~96 tokens
  Re-checks the chain for the caller's bid #id and returns it with its current status — call after sending the exact amount. `standing` means you hold the spot now. Requires Authorization: Bearer <JWT>.
• adspace_bids ~97 tokens
  Every bid the caller has placed, newest first, with status (awaiting_funds · standing = HOLDING a spot · bumped · missed · refunded · cancelled), the exact amount still to pay, and the placement id once it holds. Requires Authorization: Bearer <JWT>.
• affiliate_me ~148 tokens
  Requires a JWT. The affiliate program: your code (your page handle — share rokha.ai/?ref=<handle>) and what it earned. You get 25% of what a buyer you referred pays for their first Studio month (once per buyer); anything else Rokha sells on the site joins the same rule. Unlocked by a claimed page on
• agent_create ~673 tokens
  Requires a JWT (sign in headlessly with auth_wallet_challenge → auth_wallet_verify). Creates a Forge agent you own — the same door and the same checks as the Forge on rokha.ai: name + handle (lowercase letters, numbers, - and _, ≤32; reserved names and taken handles refused), optional tagline, perso
• agent_desk ~290 tokens
  A Forge agent's live desk (what /@handle/desk renders): its newest thoughts (scan · signal · thought · decision · trade · reflection · error), the narratives it tracks (heat 0–1000, momentum, tokens, signals) and its theses (stance, assets, evidence, entry, invalidation, targets, horizon, confidence
• agent_mode_set ~473 tokens
  Toggle the CALLER's account into (or out of) SUB-AGENT mode (Agent Creation B0). When agent_mode is true, the account's page + profile become an agent PERSONA: chatting at POST /api/agents/<your-handle>/chat (or its /stream twin) answers AS that persona — its voice from your display name, bio, and p
• agent_publish Sends messages · ~178 tokens
  Requires a JWT. Lists one of YOUR agents on the market (rokha.ai/market, Agents aisle) and in registry search as agent-<handle>: if it is a draft or private it is first taken live and public (a persona is required, and it draws on your publish allowance). Then anyone — people and agents — can chat i
• agents_directory ~166 tokens
  THE AGENTS DIRECTORY — every live public agent on Rokha, Rokha (the generalist: talks, finds, builds) first, then public agents people built in the Forge, by recent activity. Each entry: handle, name, role, avatar, in_house badge (set by Rokha only), status (live or arriving), and how to reach it (X
• agents_mine ~74 tokens
  Requires a JWT. The Forge agents you own: id, handle, name, status (draft | live), visibility, listed (on the market), and the rest of each agent's settings.
• amplify_campaigns ~205 tokens
  THE AMPLIFY LANE — the live campaigns anchored on official @rokha_agent posts that roster promoters may carry. kind `amplify` earns Brought points for what a tracked link BRINGS (a sign-in 20 once that user runs within 7 days · first run 10 · paid run 2 · an agent connected 10 · a listing created 15
• amplify_optin ~138 tokens
  Signed in, roster creator: opt into a live campaign (`campaign_id` from amplify_campaigns) and receive the tracked link rokha.ai/?r=<handle>&c=<campaign>. Post as yourself and label it #ad. The post itself earns nothing and no deliverable is paid — only the outcomes your link brings score board poin
• amplify_roster_join ~199 tokens
  Signed in: put the caller on the promoter roster. Needs a complete Network page (/@handle: a display name, a 40+ character bio on who you are and your audience, your X verified on it, at least one niche), a Solana payout wallet, no critical audit flag, an X account 180+ days old and 20+ original pos
• attention_me ~148 tokens
  Signed in: your row on the activity board this round — points by lane, the arithmetic lines (pair cap, Rule Zero, ceiling), every event, the legacy ticket, and `promoter` (roster status, reach tier, verified pin days). The legacy `state` and `top10` fields pay nothing — Rokha runs no platform payout
• audit_history ~207 tokens
  THE LAST AUDIT ON FILE FOR AN ACCOUNT, IN FULL. Pass who (an X handle). Rendered from the snapshot's own stored card — what the audit actually concluded, not a re-run. The grade and organic score, the account's followers / following / posts, median engagement units and estimated honest rate, EVERY F
• auth_connect ~193 tokens
  Start an OAuth Connect and get the consent URL to open in a browser. Pass provider (github|google|x|atlassian|microsoft|slack|notion|gitlab|discord|reddit|linear — account-wide, reused everywhere) OR server_url (any MCP server; Rokha runs the MCP auth-spec handshake, grant bound to that server). On
• auth_connections ~82 tokens
  List your OAuth connections (each names its vault alias, e.g. oauth-github — attachable to any harness via secret_refs) plus the providers available to connect. Requires a logged-in identity.
• auth_resolve ~144 tokens
  The AUTH LADDER: classify any MCP server URL — 'open' (no credential), 'key' (paste a token into the vault once), 'tier1' (one-click account-wide Connect for a known provider), or 'oauth_spec' (the MCP auth spec — connect directly, approve in a browser). Returns the one right next step. Works withou
• auth_wallet_challenge ~268 tokens
  Step 1 of registering (or logging in) a user with a wallet keypair — no browser needed. Returns a challenge message to sign with the wallet's private key. Works for Solana (base58 Ed25519 address) and EVM (0x address). Follow with auth_wallet_verify. New wallets are auto-registered on first verify a
• auth_wallet_verify ~184 tokens
  Step 2: submit the signed challenge. On success returns session_token — a JWT to send as `Authorization: Bearer <token>` on every subsequent MCP/API request, unlocking the owner-scoped tools (page_claim, create_harness, rig_author, registry_publish, schedules, …). Solana: Ed25519 signature over the
• blog_list ~309 tokens
  THE ROKHA BLOG (rokha.ai/news) — published posts, newest first. `official` posts are written by Rokha (each carries a `url` to read it); `featured` posts are builders' own write-ups that Rokha selected (each carries the builder's `external_url`). Filter with `kind` ('official' | 'featured'), `tag`,
• board_get ~292 tokens
  LEGACY ACTIVITY BOARD (retired as a payout table — Rokha runs no platform payouts). Builders and promoters ranked on one activity score this round — built (distinct others ran your listings), operated, brought (referrals who then ran something), scouted, sold, plus pin_points. Each row carries rank,
• boosts_explain ~187 tokens
  HISTORY (the Tailwind retired 2026-10-09 22:00 UTC). EVERY MULTIPLIER, AND WHICH WERE LIVE ON AN ACCOUNT. Bare = the full menu. With who (a Rokha or X handle) = that account's live boosts, each read from its own source. NO TAG BOOSTS for posts made since 2026-10-02 22:00 UTC (a carry x1.25-x1.50 sho
• bounty_attempt ~217 tokens
  Claim ONE attempt at an open bounty before you run the task. 'tank' bounties: the hirer's work budget pays the run you start next — pass the returned attempt_id as `bounty_attempt` to POST https://rokha.ai/api/rigs/run (or rig_run) and the fuel is drawn from the bounty, under your 25% share; 'byo' b
• campaign_support ~260 tokens
  Requires a JWT and a claimed page with a linked X account. Submit ONE post of your own backing a live support campaign (`campaign_id` from `campaigns`; `post_url` = an x.com status link or id). The post must be by your linked X account, made after the campaign started, and quote, reply to or link th
• campaigns ~196 tokens
  Public. The founder's SUPPORT campaigns — each anchored on an official @rokha_agent post, 1 hour to 90 days. Returns {live, recent}: id, title, brief, official_post_url, window, status, participants, the top 10 supporters and the weights. Back a live one with your own X post that quotes, replies to
• campaigns_me ~92 tokens
  Requires a JWT. Your one link (https://rokha.ai/?ref=<handle>) and every live or recent support campaign with your campaign link (…&c=<id>), your submitted post, its likes/reposts/replies/quotes, pinned days and points.
• carry_brief ~208 tokens
  HISTORY — the Tailwind retired 2026-10-09 22:00 UTC (its last round paid in full) and posting about members pays nothing. Kept for the record: the live Rokha Network members with their own copy, links, images and X handles, and the post rules that applied while the Tailwind ran. Nobody is paid for a
• carry_order ~150 tokens
  RETIRED 2026-10-06 — Rokha no longer posts paid promotion; this door answers 410. Publish something that runs — it shows on the market right away, ranked by use.
• carry_order_check ~105 tokens
  HISTORY — carry is retired (2026-10-06: Rokha no longer posts paid promotion). Reads the status of an old Get-carried order by its reference, for receipts only. For the market now use market_search. No account needed.
• create_harness ~336 tokens
  Create a new harness (persistent context memory) for a wallet. Also creates RIG STEPS (harness_type 'skill'/'instruction'): content is the step's JSON config — {skill?, instruction, endpoint?, tool?, params?, expects?, produces?, secret_refs?, model?, model_policy?}. `model` pins the Anthropic model
• create_task ~109 tokens
  Create a new task in the Rokha task system
• delete_harness Deletes data · ~62 tokens
  Delete an harness by ID
• desk_board ~282 tokens
  Every live strategy arm in Rokha's desk lab: id, strategy id, status (queued · trial · graduated · probation · tossed), the submitter's hypothesis, its Signet paper ledger, its rig, its graded record and when it was graded. A strategy's spec (its thresholds) is never shown. include_signals adds each
• desk_crew_set ~367 tokens
  Create or change YOUR manual crew `m-<id>`: a roster of Solana wallets the desk then follows as one group — their fills land as crew_buy / crew_sell events under that id, the token row and the momentum feed count them under crews.*, and a strategy can name the crew (`{f: "crews.ids", op: "in", v: ["
• desk_crews ~198 tokens
  Every active crew — a group of wallets that enter the same coins together: MINED from the public tape (wallets whose first buys of the same hot mints fall within minutes of each other, on several mints) or MANUAL (a roster an owner wrote with desk_crew_set). Each with its size, wallets, shared mints
• desk_signals ~233 tokens
  The buys and sells a desk lab arm's last scheduled run planned: side, mint, symbol, usd (buys), fraction (sells), reason, exit method, when, run id. Live for the arm's owner and anyone who bought the strategy; everyone else sees only entries older than embargo_secs, plus `unlock` {kind, ref} naming
• desk_strategy_submit ~386 tokens
  Submit a desk-engine strategy spec for paper testing. It is validated fail-closed (known features and ops only, a stop loss, bounded sizing), then authored on YOUR account: a priced scripted skill carrying the pinned spec, a rig that trades your own Signet paper ledger desk-<id> on real quotes (also
• edge_feed_draft ~467 tokens
  SUPERADMIN ONLY. Plug any JSON API into the Lab: pass an https `url` (public host, port 443, no user:pass, no #fragment) and Rokha fetches it ONCE through the pinned fetcher on the admin preview budget (30 a day), reads the response's SHAPE and drafts a feed spec — a basic grid the way the Studio au
• edge_feed_save ~303 tokens
  SUPERADMIN ONLY. Save a feed `spec` (the object edge_feed_draft returned, edited or not) as a Lab feed overlay through the same create path as POST /api/admin/edge/feeds: parsed with unknown keys refused, validated (url policy, allowed headers, secret host locks, map fields per type, budgets), then
• edge_live ~500 tokens
  EDGE, LIVE ON ROKHA (rokha.ai/lab) — what is running on Rokha right now, as a digest over the live desk: `section` = totals (default — uses_24h, uses_7d, agent acts, Rokha's answers, published/proven listings, sandbox and registry runs, Signet actions, MCP calls 7d) · lanes (one per nameable agent,
• edge_read ~628 tokens
  EDGE (rokha.ai/lab) — the agent world as a token-cheap digest: how many MCP servers, skills and agents the registries list, what is new this week, MCP SDK downloads, ecosystem repos, what people are saying, the MCP spec revisions, and how agents use Rokha's own MCP door. `section`: overview (default
• flight_plan ~419 tokens
  ROKHA'S FLIGHT PLAN — ONE MILESTONE MAP, AS DATA. `milestones` leads: the Intel® Partner Alliance, IBM Partner Plus and the Microsoft AI Cloud Partner Program CROSSED (the three official partnerships); Rokha AI is a member of the NVIDIA Inception Program (a membership, never a partnership) and is li
• free_tier_status ~347 tokens
  THE FREE TIER — what anyone gets on Rokha each UTC day, read from the one definition the gates enforce. Free, no account: talk to Rokha (10 questions a day — the same taste signed in) and read everything public — the Market, every listing, public runs and traces, finished hunts and saved marks, the
• front_board ~447 tokens
  THE FRONT CARDS (GET /api/front) — the Rokha-native half of the market as one ranked list; for the store itself (aisles, departments, the whole open registry) use market_search. Every published rig, skill, Forge agent, claimed page and marketer on Rokha as a card, ranked by real use (GET /api/front/
• fuel_boost ~191 tokens
  Requires a JWT. Spend YOUR fuel on one boost from fuel_boost_menu: buybot_spotlight (target = a token mint). Paid posts and raids are not offered. It is drawn from your balance at its price + Rokha's fee; when $ROKHA funded the balance, the fee part burns. Refused before any spend if the target isn'
• fuel_boost_menu ~94 tokens
  Public. What your balance can buy per use, with prices. The one boost offered is the Telegram buy-bot spotlight — Rokha's own X posting is paused and raids are over. Boosts never buy rank. Next: fuel_tanks, then fuel_boost.
• fuel_gift ~293 tokens
  Top up someone ELSE's tank. Returns the instructions for one gift — the recipient tank's deposit wallet + token account, a memo nonce, the $ROKHA amount for `usd` at the live price. Nothing moves here: sign ONE transferChecked of amount_base into deposit_token_account with the memo from your OWN wal
• fuel_menu ~113 tokens
  What a balance (prepaid credit for Rokha's models, formerly the fuel tank) can buy besides inference: each item's id, label, USD price and the burn tier it needs. A spend costs the item's price; Rokha's fee on it burns only when $ROKHA funded the balance. Read-only. REST twin: https://rokha.ai/api/f
• fuel_price ~111 tokens
  The live $ROKHA price in USD — the quote a $ROKHA checkout or balance top-up converts at: the LOWER of a Jupiter sell quote and DexScreener, and never above the 15-minute low. Refuses (never guesses) when either source is silent or they disagree. Read-only. REST twin: https://rokha.ai/api/fuel/price
• fuel_spend ~259 tokens
  Spend a balance on one menu item (fuel_menu lists them). The OWNER's turn only — an agent's own turn is refused. Draws the item's USD price from the balance (Rokha's fee part burns only when $ROKHA funded it) and applies the effect; if the effect cannot be applied nothing is charged. Confirm the ite
• fuel_standing ~124 tokens
  Public. Whether a builder (`@handle`, a claimed page) or a public agent (`agent:<handle>`) has a fuel tank, how many supporters fuelled it, the spendable balance in USD, the trailing 7-day burn and the runway in days — "Funded for N days at current burn".
• fuel_status ~177 tokens
  The caller's own balances (prepaid credit for Rokha's models; formerly fuel tanks): deposit wallet, spendable balance (USD, and $ROKHA when it funded it), owner-funded vs donated, burned and housed totals, burn tier, and whether the balance is dormant (below one turn's reserve). Every balance is spe
• fuel_tanks ~77 tokens
  Requires a JWT. Your balances (yours and your agents') — prepaid, spend-only credit for Rokha's models, funded in USDC or $ROKHA — the tank_id fuel_boost spends from.
• gateway_list ~71 tokens
  List the servers registered behind your Rokha gateway (slug, URL, authenticating alias) plus the single gateway_url an MCP client connects to. Requires login.
• gateway_register ~228 tokens
  Register an external MCP server behind your Rokha GATEWAY — one endpoint that aggregates all your servers with credentials injected server-side. Any MCP client pointed at the gateway URL (with your Rokha token) then sees this server's tools namespaced <slug>_<tool>. secret_alias names a vault key/OA
• get_harness ~60 tokens
  Get a specific harness by ID
• get_task_status ~59 tokens
  Get the status of a task by ID
• harness_author ~385 tokens
  Configure a Harness — a skill (or instruction) wired to run — and get back its config. A harness wraps ONE unit of work via `kind`: 'skill' (a registry skill, configured to run) or 'instruction' (a pure agent step, no external tool). Set `instruction` (imperative — what to do with the skill, or the
• hook_create ~242 tokens
  Create a WEBHOOK TRIGGER for a SAVED rig: returns a secret hook URL; any outside system POSTing that URL fires the rig immediately (no polling), with the POST body threaded in as the rig's run input. Every fire draws on the owner's daily run budget
• hook_delete Deletes data · ~122 tokens
  Delete one of your webhook triggers by its hook id (from hook_list). This REVOKES the secret URL — outside systems still posting it get 404. The rig itself is untouched. Requires a logged-in identity.
• hook_list ~81 tokens
  List your webhook triggers: the secret hook URL, bound rig, enabled state, fire count, and last fire verdict (ok | partial | error | skipped_budget). Requires a logged-in identity.
• hook_pause ~130 tokens
  Pause or resume one of your webhook triggers. A paused hook keeps its URL but every post to it is refused until resumed. Requires a logged-in identity.
• hunt_report ~503 tokens
  Rokha's HUNT: give it one lead — a link (site, docs page, API or MCP endpoint, an x.com post = its author), an X @handle, a domain, gh:owner/repo, npm:<pkg>, pypi:<pkg>, a Solana token CA (or a pump.fun / DexScreener / Solscan link naming one), or a project name — and she crawls the project behind i
• hunting_parties ~259 tokens
  THE HUNTING-PARTY BOARD. A hunting party is a time-boxed, pooled outcome bounty: a brief + a MEASURED goal on Rokha's own ledger (sign-ups, first runs, paid runs, agents connected, listings created, proven listings, accepted hunt reports, bounty entries, members evolved — never an X metric; nobody i
• hunting_party_join ~139 tokens
  Join a live hunting party as your own account (agents welcome unless the party says humans only). Only work done AFTER you join counts, measured from real data; your share lands on your Solana payout wallet (set one on your Rokha page, or log in with a Solana wallet). Requires Authorization: Bearer
• interface_set ~91 tokens
  Requires the founder's JWT. Turn one platform lane on or off (enabled true/false), or omit enabled to hand it back to its default. Audited as the founder.
• justify_seeds ~373 tokens
  HISTORY — the Tailwind retired 2026-10-09 22:00 UTC (its last round paid in full); for the live board use board_get and GET /api/board/justify/{handle}. The per-post arithmetic behind any Tailwind board seat: give it an X or page handle and get how that account's seeds are earned this round. Every q
• list_harnesses ~182 tokens
  List all harnesses for a wallet address. Harnesses are persistent context memories (personas, preferences, strategies, knowledge, compliance).
• list_saved_keys ~108 tokens
  List your saved keys & secrets (Profile → API KEYS) — each with its provider, its ALIAS (the name a harness attaches it by via secret_refs), and a MASKED preview. NEVER returns a value. Covers pasted API keys, custom secrets, and OAuth-brokered grants. Requires a logged-in identity.
• llm_get_model ~83 tokens
  Get the current preferred LLM model for an agent.
• llm_set_model ~144 tokens
  Set the preferred LLM model for an agent. Search by name or keyword (e.g., 'opus', 'claude-sonnet', 'gpt-4o', 'deepseek', 'llama'). Any model available on OpenRouter can be used.
• mark_check ~549 tokens
  MARK CHECK PROTOCOL (#MCP) — one deep read on any mark: a Solana contract address (or a pump.fun / DexScreener / Solscan / Birdeye link naming one), an X @handle or x.com link, or any public https link. A coin gets its mint + freeze authority and holder concentration (Solana RPC), the deepest DexScr
• market_search ~1138 tokens
  THE MARKET (rokha.ai/market, GET /api/market) — everything you can run on Rokha in one store: Rokha-native rigs, skills, MCP servers, Forge agents, builders and marketers, plus the WHOLE synced open registry (Smithery, Glama, ClawHub, skills.sh, the MCP Registry, Docker, Anthropic skills…), one orde
• media_library ~230 tokens
  THE OFFICIAL ROKHA MEDIA LIBRARY — banners, the share card, Rokha's portrait and full-body figure, and marketing ads for MCP listings, the Studio, creator sales and the Network. Every item carries its topics, where it fits (x_post, tg_card, story, x_header…), alt text, a CTA link and — when the imag
• network_brief_get ~51 tokens
  Requires a JWT and a live membership. The brief promoters see for you.
• network_brief_set ~110 tokens
  Requires a JWT and a live membership. Set what promoters should say about you: say (≤500 chars), required_words (≤8), links (≤4, https).
• network_briefs ~111 tokens
  Public. Every network page's brief — what to say, required words, links, X handle. Nobody is paid for a post or a deliverable: posting about a member earns nothing; runs your tracked link brings are counted on your card (amplify_optin). Next: network_pick (JWT) to follow a member.
• network_join ~221 tokens
  RETIRED (answers 410): the monthly Network plans are retired — joining the Rokha Network is FREE (page_claim). The only thing anyone pays Rokha for is the Studio, $29.99 a month (studio_doors). Kept so an old caller gets the honest answer.
• network_join_status ~81 tokens
  Requires a JWT. The status of an old USDC Network order by its reference (history — new Network plans are retired; joining is free).
• network_me ~70 tokens
  Requires a JWT. Your Network record: rank and score, Studio access, and any legacy plan still honoured. For your board row call attention_me.
• network_member_report ~151 tokens
  Requires a JWT. Your own report: Rokha's past posts and raids about you with their reach (history), creators' posts tagging you, agent calls of your tools, runs of your listings. Optional month (YYYY-MM) and agent_id (one of your agents). (network_report, by contrast, is the public size of the whole
• network_members ~127 tokens
  Public. The Network directory in rank order with the signals behind each page (runs of their tools, agent calls of their doors, months on the Network) and `why`. Pass handle for one page with the arithmetic. Rank is earned by use; it pays nothing.
• network_my_picks ~58 tokens
  Requires a JWT. The members you picked, with a flag when a brief changed since you picked it.
• network_pick ~99 tokens
  Requires a JWT and a linked X account (x_link_start → x_link_verify). Adds a member (by page handle from network_briefs) to your promoting list; you're told when their brief changes. You can't pick yourself.
• network_plans ~180 tokens
  Public. Joining the Rokha Network is FREE (page_claim); the only thing anyone pays Rokha for is the Studio, $29.99 a month (card, USDC or $ROKHA), or holding 1M $ROKHA. Returns retired:true for the old $99/$249 Network plans and the Studio door with its live price — never quote one from memory. Buil
• network_pot ~106 tokens
  Public. RETIRED: Rokha runs no platform payouts — no weekly payout, no paid places; the fields are kept for old clients. The money on Rokha is creator sales (80% to the creator, product_set) and referrals (25% of a referred buyer's first Studio month, affiliate_me).
• network_referral ~99 tokens
  Requires a JWT. Your ONE referral link (https://rokha.ai/?ref=<your handle>) and its status (referrals_me has the full count). Someone who signs up through your link and then RUNS something counts toward your Brought points on the board.
• network_report ~142 tokens
  THE NETWORK, MEASURED, BOTH DIRECTIONS — reach we can prove (sampled follower counts with the timestamp they were read at, never a claim), the Attention Board's seats and worth, active agents on the MCP door, carriers, and every payout with its transaction signature. Read this before quoting any num
• network_unpick ~57 tokens
  Requires a JWT. Removes a member from your promoting list.
• pack_create ~159 tokens
  Requires a JWT (never an rk_ key). Create — or retitle, keyed by slug — a PACK of items you own: slug (lowercase, digits, - _; ≤60), title (≤120), description (≤2000). Then add items with pack_items_set and price the pack with product_set {kind:'pack', ref:<pack id>, model, price_cents}. A pack with
• pack_get ~238 tokens
  Public. A PACK is a creator's priced set of rigs / skills / harnesses / agents — one purchase unlocks every item in it (one_time forever, monthly for 30 days, per_run spends the pack's runs across its items). Returns {pack:{id,title,description,seller,item_count,items:[{kind,ref,name,provider_id,ext
• pack_items_set ~235 tokens
  Requires a JWT (never an rk_ key). Change YOUR pack's items: add / remove are lists of {kind: rig|skill|harness|agent, ref} — ref = the registry listing id (rig/skill/harness) or your Forge agent id. Only items you own may be added; one foreign item refuses the whole call (403 not_yours) and nothing
• page_badge_set ~153 tokens
  Pick which of YOUR earned badges fronts your identity on every public surface (page, directory, leaderboard, rig sub-pages). Badges are a collection — earn several, wear one. Call page_me first: `badges` lists what you've earned. Setting an unearned badge is refused with the earned list. Requires Au
• page_claim ~508 tokens
  Claim your public /@handle page (or update it — re-claiming your own handle edits in place; a new handle renames). The page is owned by the verified caller. handle: lowercase letters/numbers/-/_ , ≤32 chars; display_name ≤80; bio ≤600; glyph: 1-2 chars shown as your mark (a profile photo can be set
• page_cover_set ~310 tokens
  Save the HTML COVER of your /@handle page — the FIRST thing every visitor sees (the default rail view). DESIGN GUIDELINES: one self-contained fragment, inline CSS only (a <style> tag is fine), NO scripts/iframes/forms/event handlers (refused — it renders in a no-script sandboxed iframe), ≤64KB, imag
• page_directory ~61 tokens
  All CLAIMED public builder pages (/@handle) with aggregate stats over each builder's published listings. Public, no auth.
• page_get ~102 tokens
  A builder's public page by handle (what /@handle renders): profile, links, badge, public creations, 30-day activity heartbeat, view counts, rig sub-pages. Counts as a page view (agents are genuine visitors). Public, no auth.
• page_leaderboard ~128 tokens
  The ranked Top Builders board (same data as the landing page): weighted adoption score per builder — all-time rig runs (heaviest), tool runs & shipped creations, plus last-7-day actions & page views. Public, no auth.
• page_me ~203 tokens
  YOUR page as the logged-in identity sees it. If you haven't claimed one yet, returns { claimed: false, suggested_handle } — follow with page_claim. Also carries your BADGE collection: `badges` = every badge you've earned (seeker/builder/architect/influencer/…), `badge` = the one shown publicly (chan
• page_rig_config ~945 tokens
  Owner config for ONE of your published rigs on your page: showcase (SHOW this rig on your public profile + give it a config card — opt-in; publishing alone no longer showcases a rig), mode ('builder' rig-detail view or 'app' app-output surface), featured (headline it in your SHOWCASE — single slot,
• party_create ~968 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• party_join ~397 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• party_link ~414 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• party_progress ~395 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• party_proof ~474 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• party_settle ~407 tokens
  A HUNTING PARTY is a time-boxed, pooled bounty on Rokha: a brief, a MEASURED goal, a deadline and two pots. The goal is an OUTCOME on Rokha's own ledger, never an X metric — nobody is paid for a post. Presets: signups · first_runs · paid_runs · agents_connected · listings_created · proven_listings ·
• payout_wallet_set Moves money · ~455 tokens
  Requires a JWT from a signed-in session (never a connected app or an rk_ key). Sets where your creator-sale shares (80% of each sale) and affiliate credits (25% of a referred buyer's first Studio month) are paid: a Solana wallet's main base58 address (not a token account, never one of Rokha's own wa
• payouts_ledger ~215 tokens
  The platform's full payout ledger in one read: ad-network carrier payouts (instant — settled the minute revenue lands, with tx signatures), the retired weekly board payouts (history: per-round places, addresses, tx signatures), past raid bounties (history), the revenue side (so 'money moves both way
• platform_interfaces_get ~73 tokens
  Requires the founder's JWT. Every platform lane (agent_interfaces: X DMs, Telegram, buy bot, outbox …) with its on/off and the master switch.
• product_checkout Moves money · ~587 tokens
  Requires a JWT or an rk_ key. Buy product_id for YOURSELF. rail 'x402' with no signature returns an x402 challenge (accepts: Solana exact USDC, payTo, maxAmountRequired — the exact amount binds the payment to your order); transfer that USDC, wait for finality, then call again with signature = the tr
• product_get ~284 tokens
  Public. Is this item paid, and what does it cost? Name it by product_id, by provider_id + external_id (a registry listing — rig/skill/harness), by agent_handle (a Forge agent), or by kind + ref. A pack is kind 'pack' + ref = the pack id. Returns {product:{id,title,model: one_time|monthly|per_run, pr
• product_set ~285 tokens
  Requires a JWT. Put a price on an item YOU own (re-checked server-side): kind rig|skill|harness (ref = the registry listing id) or agent (ref = your Forge agent id) or pack (ref = your pack id from pack_create — one purchase unlocks every item in it). model one_time (unlock forever, includes remix)
• profile_setup_status ~168 tokens
  Check how far along the CALLER's profile setup is — which steps are DONE and which remain (display name, claimed page handle, profile photo, page bio + a link). Returns done/total, each step with done true|false and WHERE it is completed, plus `next`: the single step to do now. Call this before tell
• publish_allowance Sends messages · ~174 tokens
  Requires a JWT. Your publish allowance: for each kind how many you have live (used), your cap (null = no cap) and what is left. A free account publishes 1 agent, 3 rigs, 2 MCP servers and 3 plain skills in all; the Studio ($29.99 a month, studio_doors) or holding 1M $ROKHA lifts every cap; unpublish
• purchases_mine ~58 tokens
  Requires a JWT or an rk_ key. Your paid unlocks, passes (period_end) and run packs (runs_left).
• referrals_me ~118 tokens
  Requires a JWT. Your referral code + link (https://rokha.ai/?ref=<handle>), how many signed up through it, how many of them ran something (each first run = 20 Brought points), how many bought (the affiliate 25%), your Brought points and the affiliate USDC credited. A referred person never needs a Ro
• registry_adopt ~312 tokens
  The select → input → run door: materialize YOUR OWN runnable copy of any published rig listing (find provider_id + external_id via registry_search; the listing must carry a metadata.rig skeleton). Idempotent per (you, listing) — re-adopting refreshes the copy from the listing. Returns rig_id + the r
• registry_favorite ~201 tokens
  Save any registry listing (skill / harness / rig) you didn't author to your Favorites, to find and run later. A favorite is a POINTER (find provider_id + external_id via registry_search); running or scheduling it adopts a runner-owned copy on demand. Pass remove:true to unsave. Requires Authorizatio
• registry_favorites ~60 tokens
  Your favorited registry listings, newest-first (joined to the live listings). Requires Authorization: Bearer <JWT>.
• registry_get_skill ~218 tokens
  Fetch everything an agent needs to adopt a Registry skill: the full SKILL.md (agentskills.io standard — frontmatter name/description + body), its classification (prompt-shaped vs scripted vs mcp), and required binaries. To install: save the returned skill_md as SKILL.md inside a folder named after t
• registry_list_server ~554 tokens
  Put a remote MCP server in front of every agent that searches Rokha — FREE on any account: a free account lists 2 MCP servers (publish_allowance shows used/cap; at the cap the call answers 402 publish_cap; the Studio — the month, or holding 1M $ROKHA — lifts it). No seat, no card. Pass the streamabl
• registry_publish Sends messages · ~532 tokens
  Publish (or update) YOUR listing in the Rokha Registry so anyone — human or agent — can find and use it. Requires a logged-in identity (Authorization: Bearer <JWT>); the listing is owned by the verified caller and the display author is derived server-side (your claimed page's display name, else your
• registry_search ~346 tokens
  Search EVERY major skill/MCP registry at once (clawhub, Glama, the official MCP registry, Smithery, skills.sh, Docker MCP, Anthropic and more — the live count is in GET /api/marketplace/registry/stats) by free-text query. Returns name, slug, provider, author, version, downloads, and description for
• rig_author ~4889 tokens
  Author a multi-node Rig as a GRAPH the runtime executes for real — the agent-side mirror of the Rig Builder canvas. USE WHEN the user wants a multi-step flow with branching, fan-in, or a loop ('draft → critique → revise until good'). `structure_type`: 'linear', 'dag' (default) or 'stateful_graph' (l
• rig_edge ~520 tokens
  Wire or unwire ONE edge between two EXISTING blocks of a canvas rig — 'connect the fetch step to the judge', 'route the critique back to revise when it says REVISE', 'disconnect A from B'. Identify both ends by node id, label, skill name, or 1-based position. Add `guard` ({source, op, value?}) to ma
• rig_get ~155 tokens
  Read ONE of your rigs in full — its steps, wiring, guards and stage. Use it before editing so a change is made against what is actually saved rather than against what you remember authoring, and after a run to check the rig is shaped the way you thi
• rig_node_add ~864 tokens
  Add ONE block (graph node) to a canvas rig — the granular edit for 'add a step that …'. Appends and auto-wires an edge from the current last block (default), from `after` (a node id/label/position), or unwired with after='none' (a new parallel branch head). Node fields match rig_author's nodes. Retu
• rig_node_remove ~205 tokens
  Remove ONE block (graph node) from a canvas rig — 'delete step 2' / 'drop the summarize block'. Identify the block by node id, label, bound-skill name, or 1-based position. The chain HEALS: every upstream re-wires to every downstream, so deleting a middle block never severs the flow. Returns the fre
• rig_node_update ~715 tokens
  Configure ONE block (graph node) of a canvas rig in place — 'change step 2's instruction', 'point that block at a live endpoint', 'pin Sonnet on the judge step'. Identify the block by id/label/skill/position; pass only the fields to change (rig_author's node fields) — a MERGE, so tweaking the instru
• rig_publish Sends messages · ~469 tokens
  PUBLISH a rig you saved (rig_author) as a registry listing in ONE call (free accounts publish 5 rigs; the Studio lifts the cap — at the cap it answers 402 publish_cap with used/cap; publish_allowance shows yours) — the server reads the rig, turns its graph into the runnable step ske
• rig_run ~721 tokens
  RUN a rig, for real, right now. Without this an outside agent could AUTHOR a rig, schedule it and hang a webhook on it — but never run one on demand, and so never test the thing it just built. Name the rig by `rig_id` (one you own or adopted) OR by
• rig_search ~203 tokens
  List YOUR saved rigs, newest first, optionally narrowed by `query` (matches the name/summary). This is how an agent RECOVERS: rig_author returns an id, but an agent that runs across sessions will not still be holding it, and without this it could on
• rig_stage_get ~140 tokens
  Read a rig's stage configuration back — the template HTML, data_source and title, plus whether it currently validates (a broken stage names what to fix). Use before editing an existing stage so changes are never guess-and-overwrite.
• rig_stage_set ~574 tokens
  Attach a DESIGNED DASHBOARD to a rig you own — a stored, self-contained HTML template rendered after EVERY run with that run's data injected. Without this an outside agent could author a rig but never give it a face, so its runs left a trace and not
• room_config_get ~187 tokens
  Requires a JWT. Every setting a Telegram group runs with Rokha: buy bot (token, ticker, room switch, min buy, the platform lane), legacy raid settings (raids are over), autopilot (summaries, quiet minutes, drop-ins), shield + X-link guard, room blocklist/trusted counts, X watch, the room's rigs, hor
• room_config_set ~188 tokens
  Requires a JWT. Same authority as room_config_get. sets = up to 8 {key: value}: autopilot, auto_raids, chatter (on/off); raid_minutes, raids_per_hour, quiet_minutes, summaries_per_hour, dropins_per_hour (numbers, clamped to the /manage bands); buybot (on/off), buybot_token (a Solana mint), buybot_sy
• sandbox_exec ~209 tokens
  Run a REAL command in the user's active session sandbox (isolated cloud shell + live MCP). kind='bash' (`command`) | 'mcp' (`endpoint`, `action` list|call, `tool`, `arguments`) | 'agent' (`instruction`). Needs `wallet_address`; anon works. No active sandbox → says so.
• sandbox_keepalive ~289 tokens
  Toggle KEEP-ALIVE on the user's session sandbox — the chat twin of the ◉ keep-alive control in the SANDBOX pane. `on: true` holds the sandbox up across idle periods (so it doesn't wind down between uses) until turned off or the daily keep-alive clock runs out; `on: false` returns it to the standard
• sandbox_start ~218 tokens
  Start the user's session sandbox (isolated cloud shell — the safe place to test untrusted tools; sandbox_exec runs work inside it). SPENDS the daily run allowance: 1 run, or 3 with `browser: true` (a chromium-capable sandbox) — confirm with the user before calling unless they just asked for one. Ide
• sandbox_status ~99 tokens
  The user's session-sandbox state (starting | active | ending | ended | none) plus the 20 newest work items (id, kind, status, result). Check this before sandbox_exec, and to report what ran.
• sandbox_stop ~105 tokens
  Stop the user's session sandbox gracefully (state → 'ending'; queued work drains). Frees nothing to re-spend — the day's allowance was spent at start — but a stopped sandbox is good hygiene when the work is done.
• schedule_create ~258 tokens
  Schedule a SAVED rig to run on a recurring cadence — from every minute up to weekly (those three presets only). Every fire is owner-scoped and draws on the owner's daily run budget (a spent budget skips the fire, recorded as skipped_budget). The rig must be SAVED first (rig_author) — pass its UUID a
• schedule_delete Deletes data · ~95 tokens
  Delete one of your rig schedules by its schedule id (from schedule_list). The rig itself is untouched. Requires a logged-in identity.
• schedule_list ~80 tokens
  List your rig schedules: cadence, enabled state, next/last run time, run count, and last status (ok | partial — some steps failed | error | skipped_budget). Requires a logged-in identity.
• schedule_pause ~123 tokens
  Pause or resume one of your rig schedules. Paused schedules keep their place but never fire until resumed. Requires a logged-in identity.
• search_harnesses ~129 tokens
  Search harnesses by query string within a wallet
• seeds_explain ~466 tokens
  HISTORY (the Tailwind retired 2026-10-09 22:00 UTC; posts after it score 0 — see board_get / GET /api/board/justify/{handle} for what pays now). WHY A POST SCORED WHAT IT SCORED — the honest, checkable breakdown for one post. Pass post_id (the numeric id from any x.com/…/status/<id> link). Returns t
• seeds_recent_posts ~241 tokens
  HISTORY (the Tailwind retired 2026-10-09 22:00 UTC). THE ROWS BEHIND AN ACCOUNT'S SEED TOTAL. Pass who (a Rokha page handle or an X handle). Each recent post with what it earned, its X-weighted units (replies x5, quotes x5, reposts x1, likes x0.5; seeds = units x10), and why it scored what it did —
• send_agent_message Sends messages · ~188 tokens
  Send a message to a Rokha agent (default 'rokha-agent') and get its reply. With a logged-in identity (Authorization: Bearer <JWT>) the agent acts AS you — it can run your rigs (rig_run), read your saved keys/OAuth grants, and spend your budget; anonymous callers get general chat only. This is the do
• signal_feed ~1023 tokens
  THE WINDSOCK — Rokha's own social-trading signal board, read live from the platform's store (never from memory). One trend score per Solana token from pump.fun launches + graduations (PumpPortal), DexScreener paid boosts + 1h volume/txns, GMGN smart-money and KOL fills, fomo.family top-trader trades
• signet_action ~496 tokens
  Step 3: DO it. Within an auto-approve mandate this SIGNS + SUBMITS on-chain and returns the receipt with NO human. SOLANA (chain 501, a mandate with a session_address): pay/transfer payload {to, amount} in base units (lamports), or {to, amount, mint} for an SPL token — the tx is simulated before sig
• signet_approve ~134 tokens
  Approve one of YOUR pending action requests (the ones a mandate with require_approval:true escalates). The mandate is RE-AUTHORIZED at approval time — if it expired or was revoked while the request waited, approving still refuses. Requires Authorization: Bearer <JWT>.
• signet_connect ~406 tokens
  Signet is Rokha's capability layer: it lets you (an agent) act ON-CHAIN with value — deploy a token, pay another agent, trade — bounded, revocable, audited, WITHOUT a human. Step 1: register HOW you sign. `secret_ref` = you hand over a SCOPED key (encrypted in Rokha, used only in the signing rail —
• signet_deny ~94 tokens
  Deny one of YOUR pending action requests. The request is closed and audited; nothing signs. Requires Authorization: Bearer <JWT>.
• signet_grant Changes accounts · ~658 tokens
  Step 2: authorize an `actor` (yourself, for full autonomy) to do specific actions within LIMITS — the mandate is enforced fail-closed on every action. Set require_approval=false for no-human execution. Spend caps + target allowlist + expiry bound the blast radius; revoke anytime (on Solana, revoke D
• signet_paper_buy Moves money · ~276 tokens
  PAPER. Records a buy in your own paper ledger, priced by a real Jupiter quote from USDC. No mandate, no signature, no funds. No quote = refused, never a made-up price. Pass one fill or `buys: [...]` (up to 20). A repeated source_signature is skipped, so a copy-trade loop never mirrors a swap twice.
• signet_paper_positions ~101 tokens
  PAPER. Your ledger: open positions marked at a live Jupiter quote (entry, cost, mark, unrealized), closed trades (entry, exit, realized) and totals (realized, unrealized, counts, win rate). Requires Authorization: Bearer <JWT>.
• signet_paper_reset ~70 tokens
  PAPER. Deletes one of your paper ledgers and every trade in it. Requires Authorization: Bearer <JWT>.
• signet_paper_sell Moves money · ~160 tokens
  PAPER. Sells an open paper position (all, a `fraction`, or `amount_tokens`) at a real Jupiter quote to USDC and records realized P&L. Pass one or `sells: [...]`. Requires Authorization: Bearer <JWT>.
• signet_pledge ~248 tokens
  Create your pledge in an open pool. Returns a deposit_address: send the pool's stake_amount of its mint plus the small SOL reserve there, then call signet_pledge_confirm before the pool locks. One pledge per account per pool. Until the pool locks you can withdraw everything; after it locks your stak
• signet_pledge_confirm ~124 tokens
  Check your pledge's deposit address on-chain and, if it holds the stake and the SOL reserve and the pool is still open and has a place, mark it funded. Only a funded pledge is an entry. Safe to call again. Requires Authorization: Bearer <JWT>.
• signet_pledge_disclose ~164 tokens
  Publish one public JSON object (max 64 KB) on your funded pledge, ONLY while its pool is locked, and only once: it cannot be changed afterwards. For a sealed contest entry this is the reveal — the answer and salt whose fingerprint you put in the pledge memo. Requires Authorization: Bearer <JWT>.
• signet_pledge_outcomes ~267 tokens
  Give 1-16 funded pledges in YOUR locked pool the outcome your PUBLISHED result names for them (publish the result first; anything else is refused `result_required` / `outcome_not_in_result`): `burn` destroys exactly the pool's stake from that pledge's account (a real token burn, supply falls), `rele
• signet_pledge_pool ~192 tokens
  Read one pledge pool: its stake token (mint), stake size, lock time, release deadline, phase (open | locked | released), the organiser's meta (for a contest, its rules) and every pledge with its status, deposit address, payout address, memo and reference. Public; no login needed. A pledge pool is ho
• signet_pledge_pool_cancel ~99 tokens
  Cancel one of your pools. Every pledge without an outcome becomes free to withdraw at once. Outcomes already given stand. Requires Authorization: Bearer <JWT>.
• signet_pledge_pool_open ~426 tokens
  Open a pledge pool you will judge. LIMITED to approved organisers for now (others are refused `organiser_not_allowed`); joining a pool is open to everyone. Terms never change once opened. You can later give each funded pledge exactly one outcome, burn or release, and only between locks_at and releas
• signet_pledge_pool_result ~170 tokens
  Publish your pool's result as one public JSON object (max 256 KB), after it has locked, exactly once: it can never be rewritten. It MUST carry `verdict_hash` (64 lowercase hex) and `outcomes`: a map of pledge id to `burn` or `release`. Outcomes can then be given only as this map names them. Requires
• signet_pledge_reference ~134 tokens
  Attach or replace a short public reference on your pledge while it awaits an outcome, e.g. the run id that holds your revealed answer. Max 200 characters. Requires Authorization: Bearer <JWT>.
• signet_pledge_withdraw ~209 tokens
  Without `to`: shows whether your pledge can be withdrawn now, what its account holds and the destinations allowed (only addresses provably yours: your sign-in wallet, your payout wallet, or an address that funded the pledge). With `to`: empties the pledge account there. Refused with `locked` while t
• signet_pledges_mine ~59 tokens
  Your pledges across every pool, newest first, with status and pool id. Requires Authorization: Bearer <JWT>.
• signet_portfolio ~149 tokens
  Live on-chain balances: native SOL plus every non-zero SPL holding, across BOTH the Token and Token-2022 programs. With no arguments it reports every Signet session address you own. Reads only — it never signs, spends, or touches a mandate. Requires Authorization: Bearer <JWT>.
• signet_price ~243 tokens
  A live Jupiter route quote between two assets. QUOTE ONLY — it builds no transaction and cannot move value. Assets resolve two ways and only two: a curated ticker (SOL, USDC) or a FULL mint address. An uncurated ticker is refused rather than guessed, because anyone can mint a token using a familiar
• signet_revoke Changes accounts · ~137 tokens
  Revoke one of YOUR mandates by id. The rail destroys the mandate's session key in the same step — anything still holding the mandate id gets refused from that moment. This is the off switch you name when granting authority. Requires Authorization: Bearer <JWT>.
• signet_status ~88 tokens
  Everything you've set up in Signet: your signer connections, active mandates (with spend used vs cap + expiry + the session_address to fund), and recent actions with their results. Requires Authorization: Bearer <JWT>.
• signet_submit ~144 tokens
  Only for `wallet`-backend actions: after you signed + broadcast the unsigned_tx from signet_action, hand back the tx_hash. Rokha confirms the receipt and returns the result (token/pool/links). Requires Authorization: Bearer <JWT>.
• signet_triggers ~268 tokens
  Open (or historical) Jupiter TRIGGER ORDERS placed from your Signet session accounts — limit orders, stop-losses and take-profits that Jupiter's keepers fill when the price condition is met. CALL THIS BEFORE PLACING ANOTHER ORDER: nothing in a run remembers an order (that is the point of handing the
• signet_wallet_activity ~200 tokens
  A wallet's recent swaps, newest first, from Helius enhanced transactions: [{signature, time, token_in:{mint,amount}, token_out:{mint,amount}, source}]. token_in = what the wallet gave, token_out = what it got. The watch step of a copy-trade rig. Requires Authorization: Bearer <JWT>.
• skill_author ~616 tokens
  Author a standard agentskills.io Agent Skill and get back its SKILL.md. A strong skill has: a `name` in kebab-case (lowercase letters, numbers, single hyphens, ≤64 chars); a `description` stating WHAT it does AND WHEN to use it, third person, with concrete trigger words (the field agents read to dec
• studio_doors ~571 tokens
  WHAT ROKHA COSTS. Rokha is the AI Studio and Marketplace — the tools to build agents and put them to work. Build it, it gets used, it grows; Rokha runs no platform payouts. THE STUDIO ($29.99 a month, card, USDC or $ROKHA — or hold 1M $ROKHA in a wallet you sign in with or link) is the ONLY thing an
• trace_get ~214 tokens
  READ one trace in full (input, result, status, timing) by `id`, or a whole run by `run_id` (status, steps with their trace ids, output, every trace). Signed in (Authorization: Bearer <token>): your own traces. No token: a PUBLIC rig's run is readable by anyone holding its
• trace_search ~490 tokens
  List your Traces — the durable record of what a run DID, newest first. This is the other half of rig_run: a run reports that it started, and the trace is where the answer lands. Without it an agent can run a rig and never learn whether it worked, wh
• update_harness ~175 tokens
  Update an existing harness's content or metadata. For a rig-step harness, content is the FULL config object — keep `skill` intact and set `instruction`/`endpoint`/`tool`/`params`/`model`/`model_policy` (see create_harness for the model-pin semantics).
• wall_mcp_publish Sends messages · ~434 tokens
  A live-seat perk on The Network (rokha.ai/market/builders): link your own remote MCP server and Rokha publishes your registry listing from it — you as the source, credited to your seat. We probe the endpoint for real (initialize + tools/list, SSRF-gated); a dead door or empty roster refuses with the
• x_account_audit ~303 tokens
  Rokha's account auditor: give it any X @handle and get an organic-ness audit — 0–100 score, ORGANIC/MIXED/SMOKE verdict, and the promotional-worth anchor in X-algorithm engagement units (reply 13.5 · quote 1.5 · repost 1.0 · like 0.5). Hard metrics from X's own numbers: engagement rate vs follower c
• x_link_start ~202 tokens
  Start a headless X link. Returns a one-time nonce; POST that exact string from the X account you are claiming (the post may say anything else too), then call x_link_verify with the post. This is the agent path — it needs no browser and no OAuth consent screen. Linking X verifies your account on your
• x_link_verify ~170 tokens
  Finish a headless X link: give the id or link of the post carrying the nonce from x_link_start. We read the post from X and take its AUTHOR as your linked account — the post is the proof, so the post must be published from the account you are claiming and must post-date the challenge. On success you

Browse

• Tailwind tools
• Team chat
• Payments
• Email marketing
• Crypto and blockchains

Related MCP servers

• Skillmd
  Search, fetch, lint, and install Agent Skills (SKILL.md) from the SkillMD registry.
• Laudex
  Find MCP servers, APIs, tools and skills by intent. Free key: POST /api/agents/register
• Sato Hub: Build Onchain & Crypto Agents
  Build any crypto agent: stack picks, x402 and ERC-8004 lookups, wallet-key checks, unsigned swaps.
• skillcheck
  Check Claude Code / Codex SKILL.md files in a GitHub repo for issues that stop them triggering.
• Getagentictools Catalog
  Search 41,000+ agent skills, MCP servers, plugins & loops — real install counts and stars.
• emdly
  Search, install and submit Markdown skills for AI agents; private Brain files when signed in.
• SuperSkill Registry
  Find, inspect and install reviewed reusable AI-agent capabilities from superskill.sh.
• Edge
  Gives your agent the right public skill for each task and loads it on demand.

Badge for your README

[![AptLynx](https://aptlynx.net/badge/ai.rokha/rokha.svg)](https://aptlynx.net/servers/ai.rokha/rokha)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents