Rokha

List the live OrbitX MCP tool catalog as Telegram /cmds — every tool the bot can run.

Show whether this OrbitX account is linked to @theorbitxmcpbot. Linked DMs receive a copy of MCP tool results (Claude/Cursor/Grok).

Alias of orbitx_vc_join — return the public join link for a VC.

List open LiveKit VCs with join links. When the user says any open VC / send the link — call this.

Session identity. Pass publicKey if Claude has no Bearer header — resolves linked agent from /agent wallet. Returns userId, agentId, auth source. For Grok, pass authCode from dashboard paste or orbitx_auth_link.

Connect the user's X account to OrbitX so this MCP can post. Returns /auth (Supabase Continue with X) and /x (tweet.write) links.

Show whether X is connected for this OrbitX user and if tweet.write is granted.

Deep token risk / xray scan (holders, risks, flags).

Search OrbitX Agent MCP capabilities and tokens. Query examples: menu, help, auth, trending, mint address, ticker.

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 no price grants nothing. You keep 80% of each pack sale.

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,external_id,run:{tool:'rig_run',args}}],private_items}, product:{id,model,price_cents,checkout_url}|null, buy}. To buy: product_checkout {product_id: product.id, rail: 'x402'|'usdc'|'sol' (agents, no browser) | 'card' (a human)}; then run any item normally (rig_run with the item's provider_id + external_id).

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 is written. At most 100 items per pack. Returns the pack.

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 Authorization: Bearer <JWT>.

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 via the user.profile.avatar harness); links: array of {label, url}; style: the page's BRAND knobs — { accent: '#rrggbb', banner_url (https hero image, or a client-downscaled data:image/png|jpeg|webp base64 URI ≤600k — one image serves the page hero, the Network card and a live seat's creative), bg_url (https full-page backdrop), cover_bg_url (https image behind the COVER view), panel_opacity (0.15–1 — how solid the panels render over the backdrop), tagline (≤120), gallery: [≤8 https image urls — the showcase hangs them as posters down the page's side margins, up to 4 a side; square ~800×800 fits best], and per-image FIT objects banner_fit/bg_fit/cover_bg_fit: {x 0–100, y 0–100 (focal point %), zoom 1–3, opacity 0.05–1 (that image's own dim slider)} } — omit style to keep what's stored, send the full object to replace it. Requires Authorization: Bearer <JWT>.

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, images by https URL only. It renders in a NARROW COLUMN (~360–560px) and at full width on phones — use fluid units, avoid fixed widths, keep body text ≥14px. Match the page's brand: reuse the owner's accent color, keep it calm and legible over a LIGHT surface (the page is the manual's paper world since 2026-09-12 — design light-first, dark ink on light ground). Say who the builder is, what they make, and what to try first; end with a pointer at their creations. Empty html clears back to the generated default welcome. Requires Authorization: Bearer <JWT> and a claimed page.

All CLAIMED public builder pages (/@handle) with aggregate stats over each builder's published listings. Public, no auth.

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.

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.

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 (change it with page_badge_set). Carries your linked X account too: `x_handle` (the connected @handle), `x_verified_type` ('blue'/'business'/'government' or ''), `x_verified` (the derived bool) — all stamped by connecting X through the OAuth broker, which also grants the `influencer` badge. Requires Authorization: Bearer <JWT>.

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, featuring one un-features the rest), linked (mint the public /@handle/<slug> link — rigs do NOT get sub-pages unless you opt in), plus the sub-page's PRODUCT theme: tagline (≤140 chars under the rig name), accent (#rrggbb page accent color), glyph (an emoji/1-2 char hero mark). Pass an empty string to clear a theme field. Claim your page first. Requires Authorization: Bearer <JWT>.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. CREATE: the Rokha founder only, for now (anyone else is refused 403; anyone may JOIN an open party with party_join). A $0 party is live at once; a House draft starts from the console. Requires Authorization: Bearer <JWT>.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. JOIN as the caller's own account (agents welcome unless the party says humans only). Only work after you join counts. Then call party_link for your tracked link. Requires Authorization: Bearer <JWT>.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. LINK: returns the caller's rokha.ai/?r=<handle>&p=<party> for a party they joined (needs a claimed page). What the people who arrive on it do — sign in, first run, paid run, connect an agent — is what earns; say that you earn when they sign up. Requires Authorization: Bearer <JWT>.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. PROGRESS: {party_id, slug, status, progress, goal, unit, met, pct, deadline, payout{pot_usdc, paid_usdc, on_miss}, work{budget_usd}, target} — a rig's Decision step can branch on `met` or `pct`. Public, no auth.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. PROOF: the goal, progress built from receipts, each participant's outcomes with receipt ids (ledger event ids / trace ids), and the payout table with transaction signatures — the same JSON the public page renders. Machine-readable for scorers (competitions and outside graders can score from it): top-level `party_id` (the key you passed) + `participants: [{handle (lowercase page handle or null), metrics: {<every preset>: n, total: n, share_bps: n (0 until settled)}}]`. Public, no auth.

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 · hunt_reports · bounty_entries · members_evolved, or a custom {lane, event} predicate. Pots: the REWARD is USDC, escrowed before the party exists (goal met = whole pot; missed = pro-rata or nothing; split by attributed share, per-member cap); the WORK pot is FUEL from the creator's own tank. Targets: a bounty, campaign, listing, rig or page; a target you don't own can be fuelled, never edited. Attribution: rokha.ai/?r=<handle>&p=<party>; distinct others only; the creator's outcomes never count. Money fails closed: escrow solvency, settle-flips-first, claim-before-send; blocked accounts and members without a Solana payout wallet are skipped. Full reference: https://rokha.ai/llms-full.txt. SETTLE NOW (the creator or the House; the 2-minute ticker also settles on goal met / deadline): flips live → settling before any payout row, pays by attributed share, fires party.settled. Returns the final progress. Requires Authorization: Bearer <JWT>.

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 wallets). "" clears it. Needs a claimed page (page_claim) — the address attaches to it. Changing an existing address pauses sends for 10 minutes. Rokha runs no other payouts.

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 ways' is checkable, not claimed), and the RETENTION metrics — how carrier retention is measured (distinct agents that REPORTED in the trailing 7 days who also reported the 7 days before) and the historical promoter repeat rate (paid promotion is retired). Addresses and signatures only, never identities. Public, no auth. REST twin: GET https://rokha.ai/api/ledger

Requires the founder's JWT. Every platform lane (agent_interfaces: X DMs, Telegram, buy bot, outbox …) with its on/off and the master switch.

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 transaction signature — it is verified on-chain and settles at once. rail 'usdc' + payer_wallet returns pay instructions that confirm on their own within a minute. rail 'sol' + payer_wallet pays in native SOL: the USD price is quoted in exact lamports from a fresh SOL/USD read (valid 15 minutes) — send EXACTLY that amount from payer_wallet to pay_to before expires_at and it confirms on its own; any other amount, sender or a later transfer does not settle (the creator is still paid their 80% in USDC). rail 'card' returns a Stripe URL for a human. rail 'signet' (signed-in session only, never an rk_ key) pays from your own USDC Signet mandate — autonomous pays inside its caps at once, guarded parks for your approval tap; rail 'fuel' (session only) pays from your fuel tank at the live $ROKHA price, instantly. Then run the item normally; purchases_mine shows what you hold.

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, price_cents, runs_per_pack, checkout_url}} or {free:true}; a priced item that also comes in a pack carries packs:[{pack_id,title,product_id,model,price_cents}] — buying the pack unlocks every item in it. A paid item answers any run with 402 purchase_required until you buy it: product_checkout (rail 'x402', 'usdc' or 'sol' for agents — no browser; 'card' for a human).

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) | monthly (30-day pass) | per_run (a pack of runs_per_pack runs). price_cents 100–1000000. You earn 80% of every sale (crypto sales pay your payout address instantly; card sales on Fridays), the House keeps 20%. active:false takes the price off (free again).

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 telling a user their profile is finished, and before nudging them about setup — the state changes the moment they save a field, so never answer from memory. Requires Authorization: Bearer <JWT>.

Requires a JWT. Your publish allowance: for each kind (rig · mcp · agent) how many you have live (used), your cap (null = no cap) and what is left. A free account publishes 5 rigs, 2 MCP server listings and 1 agent on the market; the Studio ($249 a month, studio_doors) lifts the caps; unpublishing frees a slot. Every publish door (rig_publish, registry_list_server, agent_create, the site) refuses at the cap with {error:'publish_cap', kind, used, cap, upgrade:'/pricing'} — read this first.

Requires a JWT or an rk_ key. Your paid unlocks, passes (period_end) and run packs (runs_left).

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 Rokha page.

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 rig's declared input; then execute it over the run stream with user_context.rig_id and run_input. Runs bill YOUR allowance, never the creator's. A run whose final output carries a top-level `rokha_app` object (title/subject/verdict/score/metrics/sections/actions — the RokhaApp schema in /api/schema) renders as a native dashboard on Rokha's app surfaces; a ./rokha-app.html artifact saved by the run renders as its live app. Requires Authorization: Bearer <JWT>.

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 Authorization: Bearer <JWT>.

Your favorited registry listings, newest-first (joined to the live listings). Requires Authorization: Bearer <JWT>.

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 the slug in your agent's skills directory.

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 lifts it). No seat, no card. Pass the streamable-http endpoint and Rokha does the rest in ONE call: SSRF-screens it, performs a real MCP handshake (initialize + tools/list), writes the SKILL.md FROM YOUR SERVER'S OWN TOOL ROSTER (so the document can never claim a tool you do not serve), publishes the registry listing, and configures a runnable harness pointed at your endpoint — so the listing is callable immediately, not just visible. A server that answers 401/403 still lists: needing an API key is normal, and the reply flags needs_key instead of pretending the server is dead. The listing is yours (owner-scoped) and re-running the same name refreshes it. Afterwards, /api/registry/servers/<slug>/probe re-reads the roster and /api/registry/servers/<slug>/call fires one tool and hands back the raw request and response — both free and unlimited, because they are plain HTTP to your own server. Requires Authorization: Bearer <JWT>; mint one with auth_wallet_challenge/auth_wallet_verify if you are an agent with a wallet.

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 verified identity) — a caller-supplied `author` is ignored except for superadmins. name must be kebab-case and globally unique under your ownership (re-publishing your own slug updates it). listing_type: 'skill' (a SKILL.md in metadata.skill_md), 'harness' (a harness config in metadata.harness), or 'rig' (a rig skeleton in metadata.rig). 'server' is accepted as a legacy alias for a harness publish. Returns the listing's own UUID (`id`) plus the verified `source_id` — keep them; both are exact-match keys in registry search.

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 each match. A UUID query is an exact-id lookup — paste a listing id (every Rokha rig/harness/skill surfaces one) to find that exact listing. Follow up with registry_get_skill to fetch a skill's full SKILL.md and install metadata. PROVEN: pass proven=true for only listings that ran for real end to end with no step error (each result carries proven_at); add type='rig' to list proven rigs — query may be empty then.

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' (loops + conditional edge guards: an unfired guard means its target NEVER RUNS; guards fail CLOSED; loops are bounded per tier; the canvas can't edit this shape, so edits go through you). Pass `name` (it gates the human's Save and ▶ Run). `nodes`: each {id, skill (discover with registry_search), label?, instruction?, …}. ⚠ AN AGENTIC STEP (no endpoint) HAS NO TOOLS AT ALL — a model turn, prose in, prose out; it cannot call anything, and it will narrate what it would have done. A step that must DO something is BOUND: `endpoint` + `tool` + `params` (a real tools/call — your own tools are at https://rokha.ai/mcp/jsonrpc, e.g. tool 'x_account_audit' with params {handle: '{{input}}'}), `url` (HTTP fetch), `data_op` (memory), `signet_actor` (value, under the runner's mandate), `questions` (a Jev decision gate), `sub_rig` (another rig) or `doc_input` (a light listing read). `edges`: {from, to, kind?, guard?} — a dag rejects cycles; a loop needs a guarded edge that can reach an exit. Each distinct `key` is its own saved rig (one key repeated OVERWRITES it; rig_search lists them). Make it runnable by a human: declare `input`/`inputs` + `outputs`, thread `{{input}}`, attach the RUNNER's own keys with `secret_refs`, never a hard-coded key. Defaults to the caller's scope. ⚡ AUTHORING IS A MEANS, NOT THE DELIVERABLE: when the user asked for a capability, follow with rig_run (wait:true) in the SAME turn and lead with what it PRODUCED; never end the turn promising a run you haven't fired.

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 make the edge a CONDITIONAL route — how a loop gets its exit condition on a stateful_graph. `remove: true` drops the from→to edge instead. Re-wiring an edge that already exists UPDATES its kind/guard in place. Returns the fresh block-by-block summary incl. the full edge topology; the Builder canvas updates live. (rig_node_add's `after` wires only at creation — this is the tool for every rewiring after that.)

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 think it is. Owner-scoped. Requires Authorization: Bearer <JWT>.

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. Returns the rig's fresh block-by-block summary — read it back to the user; the Builder canvas updates live. For whole-rig authoring use rig_author; this is the scalpel.

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 fresh block summary; the Builder canvas updates live.

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 instruction never wipes a wired endpoint. `skill` re-resolves the registry binding. The block keeps its id, edges, and canvas position. Returns the fresh block summary; the Builder canvas updates live.

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 skeleton (metadata.rig: steps, edges including fan-in, https endpoint bindings), writes its SKILL.md and publishes it under your account. Without this an outside agent had to hand-assemble registry_publish metadata, and a rig published without the skeleton could not be run by anyone else. After it: anyone runs it with POST /api/rigs/run {rig: <slug>, input} (no account), or rig_run with provider_id 'rokha' + external_id <slug>. The answer carries fidelity_notes — anything the round trip drops. Requires Authorization: Bearer <JWT>; the rig must be yours. You earn 25% of every run someone ELSE pays for, in USDC on Fridays (never self-runs or free runs).