ai.rokha/rokha · v1.0.0 · agents-and-memory
Rokha is healthy: it completed an MCP handshake in 3852 ms and exposes 282 tools.
Search a registry of agent skills and MCP servers, then run them for real. No install, traced.
Endpoint: https://rokha.ai/mcp/jsonrpc (streamable-http)
Repository · Website · JSON · Add to my inventory
| Users (last 30 days) | 0 |
| Handshake | Healthy |
| Auth needed | None |
| Tool count | 282 |
| Latency | 3852 ms |
| Last checked (UTC) | 2026-10-15T16:20:12.427Z |
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-10-15T16:20:12.427Z | Healthy | 3852 | |
| 2026-10-14T12:15:40.175Z | Healthy | 1221 |
send_agent_message | 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 |
create_task | Create a new task in the Rokha task system |
get_task_status | Get the status of a task by ID |
list_harnesses | List all harnesses for a wallet address. Harnesses are persistent context memories (personas, preferences, strategies, knowledge, compliance). |
get_harness | Get a specific harness by ID |
create_harness | 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 |
update_harness | 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). |
delete_harness | Delete an harness by ID |
search_harnesses | Search harnesses by query string within a wallet |
llm_set_model | 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. |
llm_get_model | Get the current preferred LLM model for an agent. |
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 |
registry_get_skill | 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 |
rig_search | 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_get | 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 |
trace_search | 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 |
rig_run | 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_publish | 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_stage_set | 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 |
skill_author | 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 |
harness_author | 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 |
schedule_create | 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_list | 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_delete | Delete one of your rig schedules by its schedule id (from schedule_list). The rig itself is untouched. Requires a logged-in identity. |
schedule_pause | Pause or resume one of your rig schedules. Paused schedules keep their place but never fire until resumed. Requires a logged-in identity. |
hook_create | 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_list | 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_delete | 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. |
list_saved_keys | 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. |
gateway_register | 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 |
gateway_list | List the servers registered behind your Rokha gateway (slug, URL, authenticating alias) plus the single gateway_url an MCP client connects to. Requires login. |
auth_resolve | 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_connections | 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_connect | 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 |
hook_pause | 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. |
rig_node_add | 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 | 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 | 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_edge | 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_stage_get | 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_author | 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 |
trace_get | 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 |
sandbox_exec | 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_start | 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 | 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 | 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. |
sandbox_keepalive | 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 |
signal_feed | 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 |
fuel_price | The live $ROKHA fuel price in USD — the number every fuel draw 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_menu | What a $ROKHA fuel tank can buy besides inference: each item's id, label, USD price and the burn tier it needs. Half of every $ROKHA spent pays the model, the other half burns. Read-only. REST twin: https://rokha.ai/api/fuel/menu |
fuel_status | The caller's own $ROKHA fuel tanks: deposit wallet, spendable balance (tokens + USD), owner-funded vs donated, burned and housed totals, what the owner may withdraw, burn tier, and whether the tank is dormant (below one turn's reserve). On an agent's own turn it shows only that agent's tank. Read-on |
fuel_spend | Spend a fuel tank 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 in $ROKHA at the live price (half burned, half to House) and applies the effect; if the effect cannot be applied nothing is charged. Confirm the item and pric |
registry_publish | 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 |
auth_wallet_challenge | 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 | 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 |
page_directory | All CLAIMED public builder pages (/@handle) with aggregate stats over each builder's published listings. Public, no auth. |
page_leaderboard | 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_get | 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. |
carry_brief | 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 |
seeds_explain | 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 | 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 — |
boosts_explain | 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 |
audit_history | 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 |
studio_doors | WHAT ROKHA COSTS — one way in (since 2026-10-09). 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 ($249 a month, card or USDC) is the ONLY thing anyone pays Rokha for: the builder's |
flight_plan | 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 |
network_report | 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 |
edge_feed_draft | SUPERADMIN ONLY. Plug any JSON API into Edge: 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 auto- |
edge_feed_save | SUPERADMIN ONLY. Save a feed `spec` (the object edge_feed_draft returned, edited or not) as an Edge 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), the |
board_get | 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, |
front_board | 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/ |
market_search | 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 (ranked by real use, exactly like the front board), then the WHOLE synced open registry (Smithery, Glama, ClawHub, skills.sh, the |
blog_list | 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`, |
attention_me | 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 |
amplify_campaigns | 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_roster_join | 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 |
amplify_optin | 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 |
justify_seeds | 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 |
agent_desk | 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 |
x_account_audit | 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 |
adnet_feed | 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_stats | 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. |
payouts_ledger | 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 |
adnet_rounds | 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_join | 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_report | 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_me | 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>. |
adspace_bid | 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_bids | 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>. |
adspace_bid_check | 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_bid_cancel | 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>. |
ads_order | 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_orders | 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>. |
ads_order_check | 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_campaign_update | 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_campaign_pause | Stop a live campaign from being recalled or served (the clock keeps running). Requires Authorization: Bearer <JWT>. |
ads_campaign_resume | Put a paused campaign back in the agent's memory and the /ad rotation. Requires Authorization: Bearer <JWT>. |
page_me | 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 |
profile_setup_status | 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 |
page_cover_set | 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 |
agent_mode_set | 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 |