Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

docs(prompts): twenty more build briefs covering the rest of the agent-platform gap, and a five-tier index

qhqf14c28f589891
diff --git a/docs/prompts/17-unified-mcp-endpoint.md b/docs/prompts/17-unified-mcp-endpoint.md
new file mode 100644
index 000000000..31ef1b45f
--- /dev/null
+++ b/docs/prompts/17-unified-mcp-endpoint.md
@@ -0,0 +1,24 @@
+# 17. One MCP endpoint, one OAuth, every tool
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+We run seven hosted MCP servers (`docs/mcp.md`): main, 3D, studio, agent wallet, bazaar, launch, and a partner lane. A developer has to know which one holds the tool they want, configure several, and authorize each. The best platforms expose their entire surface as one URL behind one OAuth grant, with tool groups the user can switch on and off, and the count of tools is a headline number.
+
+## Build
+
+- `https://three.ws/mcp` (and `/api/mcp/all` as the route): a single Streamable HTTP server that mounts every tool from every existing server, namespaced by the group field from prompt 03 (`agents_`, `wallet_`, `assets_`, `x402_`, and so on) with collision detection at boot (`npm run check:mcp-tools`, wired into `npm run gate`, fails on duplicate names or missing group and tier).
+- One OAuth 2.1 grant with the union of scopes; each group maps to a scope so a consent screen shows what a client gets. API keys work the same way.
+- The prompt 02 resources and prompts all live here too.
+- Per-key and per-session tool selection from prompt 03 decides what `tools/list` returns; the default shows the read and write tiers of every group.
+- The existing seven servers keep working as thin views of the same registry, so nothing already installed breaks. Their docs point to the unified endpoint as the default.
+- Registry listings: update `server.json`, `/.well-known/mcp.json`, the MCP registry manifests, and the Claude plugin marketplace in `.claude-plugin/marketplace.json` to lead with the unified server. Publish the stdio twin as `@three-ws/mcp` under `packages/`, which proxies to the unified endpoint with a key.
+- A live tool count and group list on `/mcp` (page in `data/pages.json`) and in `docs/mcp.md`, generated at build from the registry so the number never rots.
+
+## Acceptance
+
+- One `npx three-ws setup` entry gives Claude Desktop every three.ws tool.
+- `npm run check:mcp-tools` fails when two servers define the same tool name.
+- The tool count printed on `/mcp` equals `tools/list` with every group enabled.
+- Docs updated, changelog entry tagged `feature, sdk`, `npm test` green.
diff --git a/docs/prompts/18-open-model-roster.md b/docs/prompts/18-open-model-roster.md
new file mode 100644
index 000000000..93ba69e57
--- /dev/null
+++ b/docs/prompts/18-open-model-roster.md
@@ -0,0 +1,21 @@
+# 18. Open-model roster and free-tier models
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+The model roster in `api/brain/chat.js` and `api/_lib/chat-models.js` is Claude, GPT, one open-weights GPT variant, Qwen through a provider package, IBM Granite and NVIDIA NIM. Users expect to choose Llama, DeepSeek, Kimi, Mistral and Qwen for an agent's brain, to have at least one genuinely free model for the free tier, and to switch per message. GCP is pre-approved: Vertex AI Model Garden serves these models, so no new paid vendor is needed.
+
+## Build
+
+- Add the open models through Vertex AI (Model Garden endpoints or partner models on Vertex) in the LLM chain (`api/_lib/llm-tool-chain.js`, `chat-models.js`, `llm-pricing.js`, `llm-health.js`): Llama 4 family, DeepSeek V3 and R1, Kimi K2, Mistral Large and Small, Qwen 3, plus Gemini 2.5 Pro and Flash. Each entry carries input and output price, context window, tool-calling support, and a health probe. Failover chains stay intact; a model without tool calling is refused for runs and allowed for chat.
+- Free tier: mark at least two models as free and route the free-tier quota from prompt 05 to them, with the daily allowance in `app_settings` and shown on `/pricing`.
+- Per-agent default model and per-message override everywhere a message is sent (web, SDK, gateways, MCP `chat_with_agent`).
+- Model picker UI on the agent editor and in chat: grouped by provider, price per million tokens, context, tool support, latency from the health probe, free badge. Every state designed, including "provider degraded" from `llm-health.js`.
+- `GET /models` from prompt 05 and the `three://models` resource reflect all of it.
+
+## Acceptance
+
+- Create an agent on a Llama model and on DeepSeek; each answers a tool-using request end to end.
+- Exhausting the free-tier allowance on a free model returns the quota error with the reset time.
+- `docs/agent-runtime.md` and `docs/api-reference.md` updated; changelog entry tagged `feature`; `npm test` green.
diff --git a/docs/prompts/19-self-custody-and-signers.md b/docs/prompts/19-self-custody-and-signers.md
new file mode 100644
index 000000000..39c163e82
--- /dev/null
+++ b/docs/prompts/19-self-custody-and-signers.md
@@ -0,0 +1,23 @@
+# 19. Self-custody mode, external signers, key export, and the user's private wallet
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Agent wallets are custodial: keys are generated and encrypted by the platform (`api/_lib/agent-wallet.js`) and the platform signs. Non-custodial transaction builders exist for a few actions (`api/tx/solana/[action].js` `build-transfer`, `build-swap`), and the studio can connect a browser wallet, but there is no coherent self-custody story: no way to run an agent whose keys the platform never holds, no export with a sane re-encryption ceremony, no external signer registration, no view of the user's own connected wallet next to the agent's, and no balance history over time.
+
+## Build
+
+- **Non-custodial path for every fund-moving route.** Each financial route and tool from prompts 05 to 16 accepts `signer: "external"` and returns an unsigned, simulated, base64 transaction plus a `tx_id`; `POST /tx/submit` broadcasts a signed one and reconciles it to the same ledger rows. The SDK exposes this as the default when no `agentId` is passed. The confirm-flag rule still applies to the custodial path only; the external path is confirmed by the signature itself.
+- **External signer registration:** `PUT /agents/:id/signer` with modes `platform`, `external` (a public key the user signs with), and `session` (a delegated session key with a spend cap and expiry the user grants from their wallet, so an agent can act unattended within limits). Migration for `agent_signers`.
+- **Key export:** `POST /agents/:id/wallet/export` (financial, `confirm_export`): requires a fresh re-authentication, encrypts the secret to a passphrase the user types in the browser (never sent to the server in plaintext), shows it once, records the export in `agent_custody_events`, and offers "rotate after export" which generates a new platform key and sweeps.
+- **Private wallet view:** `GET /me/wallet` and tool `get_private_wallet_balance` for the user's connected wallet; `get_wallet_summaries` returns agent wallets and the private wallet together.
+- **Balance history:** a cron snapshots every agent wallet's balances hourly into `agent_balance_history`; `GET /agents/:id/wallet/history?range=` and tool `get_balance_history` return the series; the wallet page draws it (follow the `dataviz` skill).
+- Docs: `docs/agent-wallets.md` gains "Custody modes"; `docs/api-reference.md` sections; changelog entry tagged `feature, security`.
+
+## Acceptance
+
+- A swap built with `signer: "external"`, signed in a browser wallet, submitted through `/tx/submit`, appears in the custody ledger with the signature.
+- A session key with a 1 USDC cap refuses a 2 USDC transfer.
+- Export shows the encrypted secret once and never logs it.
+- `npm test` green.
diff --git a/docs/prompts/20-local-agent-runtime-tui.md b/docs/prompts/20-local-agent-runtime-tui.md
new file mode 100644
index 000000000..e1e370293
--- /dev/null
+++ b/docs/prompts/20-local-agent-runtime-tui.md
@@ -0,0 +1,27 @@
+# 20. Local agent runtime and terminal UI: `three-ws agent`
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Everything an agent does today runs on our servers. There is no way to run a three.ws agent on your own machine or VPS with a real terminal interface, talk to it, let it work on local files and long tasks, and still use the platform's wallet, tools and marketplace through the API. The `three-ws-tty` and `tty-avatar` bins under `packages/` render an avatar in a terminal; `@three-ws/agent-runtime` is the loop the server uses. The strongest open agents ship exactly this: a TUI, sessions, slash commands, subagents, cron, and a gateway process, installable anywhere.
+
+## Build
+
+A new package `packages/agent-cli/` published as `@three-ws/agent`, reachable as `three-ws agent` from the CLI in prompt 01 and as `npx @three-ws/agent`.
+
+- **Runtime:** wraps `@three-ws/agent-runtime` for local execution with the unified MCP endpoint from prompt 17 as its tool source (plus local tools: file read and write, shell in the sandbox from prompt 25, web fetch from the tool gateway in prompt 26). Model access through the account's credits (prompt 16) or any OpenAI-compatible base URL the user sets.
+- **TUI:** multiline editor, slash-command autocomplete (`/model`, `/agent`, `/wallet`, `/skills`, `/runs`, `/new`, `/sessions`, `/cron`, `/subagent`, `/help`), streaming tool output, interrupt and redirect, the terminal avatar from `tty-avatar` optional in a pane. Use `ink` or the terminal library already in `packages/`; do not hand-roll a renderer.
+- **Sessions:** local SQLite with full-text search over past conversations (`/search`), resume by id, export to JSON.
+- **Subagents:** `/subagent <goal>` spawns an isolated child run with its own context and budget, reporting back into the parent.
+- **Cron:** `/cron "every weekday 9am" "post the portfolio summary to Telegram"` stores natural-language schedules parsed with a maintained cron-parsing package, executed by a local scheduler or, when the machine is off, by prompt 05 automations on the server (the user picks).
+- **Gateway mode:** `three-ws agent gateway` runs the local agent as the backend for the chat gateways in prompts 13 and 24, so messages from Telegram reach the machine the user chose.
+- **Install breadth:** Linux, macOS, Windows native (PowerShell installer), WSL, Termux, and a Nix flake; Docker image with a `docker-compose.yml`; a $5 VPS guide.
+- **Docs:** `docs/agent-cli.md`, `packages/agent-cli/README.md`, `STRUCTURE.md` row, changelog entry tagged `feature, sdk`.
+
+## Acceptance
+
+- On a clean VPS: install, `three-ws agent`, ask the agent to check its wallet balance and to write a file; both happen.
+- `/subagent` runs in parallel with the main session and reports back.
+- A cron fires on schedule with the machine on, and hands off to the server when the user picks server mode.
+- `npm test` green with TUI component tests and session search tests.
diff --git a/docs/prompts/21-agent-memory-and-self-improvement.md b/docs/prompts/21-agent-memory-and-self-improvement.md
new file mode 100644
index 000000000..5177b4dbe
--- /dev/null
+++ b/docs/prompts/21-agent-memory-and-self-improvement.md
@@ -0,0 +1,24 @@
+# 21. Agent memory, cross-session recall, and skills learned from experience
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+An agent has a persona and a chat history, and nothing else persists: no memory it curates, no model of the person it works for, no search over its own past sessions, and no way to turn a task it completed into a reusable skill. The best agents run a closed learning loop: they save memories, are nudged to persist what matters, search prior conversations, build a deepening user model, and author skills after complex tasks, then improve those skills while using them.
+
+## Build
+
+- **Memory store:** `agent_memories` migration (agent, kind: fact, preference, procedure, user-model; text, source run or message, confidence, created, last used). Tools `memory_save`, `memory_search`, `memory_list`, `memory_forget` (the last one irreversible, `confirm_delete`). Injected into the system prompt as a bounded, ranked section; ranking by recency and use.
+- **Nudges:** the runtime (server loop in `api/agent/run.js` and the local runtime from prompt 20) prompts the agent at the end of a run or every N turns to persist anything worth keeping, with the nudge text in the prompt 03 skill.
+- **Session search:** full-text index over messages and run steps (Postgres `tsvector` on Neon; SQLite FTS locally), tool `search_sessions` returning summaries generated on demand and cached.
+- **User model:** a structured, editable "about the user" document per account that the agent updates through `memory_save` with kind `user-model`; the user sees and edits it on `/settings/memory` (in `data/pages.json`), with per-memory delete and a global off switch. Every state designed.
+- **Skills from experience:** after a run with more than N tool calls succeeds, the runtime drafts a prompt-only custom skill (prompt 04) capturing the procedure, saves it disabled, and notifies the user to review and enable. While a skill is in use, the agent may propose edits; edits are versioned and the user can roll back.
+- **Privacy:** memories are per account, never shared across accounts or into the community registry, and excluded from any marketplace transfer (prompt 10) unless the seller opts in.
+- **Docs:** `docs/agent-memory.md` linked from `docs/start-here.md` and `docs/agent-runtime.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Tell an agent a preference in one session; a new session honors it without being told.
+- A completed multi-step run produces a draft skill visible on the agent's skills page.
+- Deleting a memory removes it from the next prompt; the off switch stops all writes.
+- `npm test` green.
diff --git a/docs/prompts/22-external-mcp-integrations-for-agents.md b/docs/prompts/22-external-mcp-integrations-for-agents.md
new file mode 100644
index 000000000..40042ae87
--- /dev/null
+++ b/docs/prompts/22-external-mcp-integrations-for-agents.md
@@ -0,0 +1,21 @@
+# 22. External MCP servers as agent tools: an integrations catalog with one-command install
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Our agents use our tools. They cannot be connected to the hundreds of third-party MCP servers that exist for Stripe, Notion, Linear, Slack, GitHub, Google Workspace, Cloudflare, Supabase, Sentry and the rest, so an agent cannot file an issue, read a doc, or check a payment for the person it serves. The best agent products ship a catalog of vetted servers with `install <name>` and per-user OAuth.
+
+## Build
+
+- **Catalog:** `data/mcp-catalog.json` with at least sixty vetted remote or stdio MCP servers (name, vendor, transport, URL or npm package, auth type, scopes, tool count, category, docs link), validated at build, rendered on `/integrations` (in `data/pages.json`) with search and categories.
+- **Per-agent connections:** migration `agent_mcp_connections` (agent, catalog id or custom URL, auth state, encrypted credentials with the wallet secret encryption, enabled tools, tier overrides). Routes `GET/POST/DELETE /agents/:id/mcp` and `POST /agents/:id/mcp/:conn/auth` (OAuth flow with the platform as the client, tokens stored encrypted, refresh handled). Custom servers accepted by URL with a safety review step that lists the tools before enabling.
+- **Runtime:** the server loop and the local runtime mount connected servers' tools under `ext_<name>_` names, each classified into the prompt 03 tiers by a rules file in the catalog entry (write tools off by default for a new connection). Tool results from external servers are untrusted data.
+- **CLI and MCP:** `three-ws mcp install <name> --agent <id>`, tools `list_integrations`, `install_integration`, `remove_integration` (prompt 05 integrations become this).
+- **Docs:** `docs/integrations.md` linked from `docs/start-here.md`; catalog contribution guide; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Connect an agent to a public documentation MCP server and a GitHub MCP server through OAuth; the agent answers a question that needs each.
+- A write tool on a newly connected server is hidden until enabled.
+- `npm test` green with catalog validation and connection lifecycle tests.
diff --git a/docs/prompts/23-distribution-into-agent-frameworks.md b/docs/prompts/23-distribution-into-agent-frameworks.md
new file mode 100644
index 000000000..987647417
--- /dev/null
+++ b/docs/prompts/23-distribution-into-agent-frameworks.md
@@ -0,0 +1,22 @@
+# 23. three.ws inside every agent framework: distributions, plugins and skins
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+The Claude plugin marketplace exists (`.claude-plugin/marketplace.json`) and `.mcp.json` shows the manual path. Nothing else meets users inside the agent they already run. The most effective growth pattern in this space is a downstream distribution of a popular open-source agent with the platform pre-wired: one command, the platform's theme, the skill installed, the MCP authorized.
+
+## Build
+
+For each of Claude Code, Codex CLI, Gemini CLI, Hermes Agent, OpenHands, Goose, Cline and Continue:
+
+- A first-class install path: plugin, extension, or config recipe, whichever the framework supports, published where that framework's users look (its marketplace or registry), that installs the unified MCP endpoint from prompt 17, the model-facing skill from prompt 03, and the setup command from prompt 01.
+- Where the framework supports distributions or skins (Hermes-style), publish `three-ws-agent` as a downstream distribution repository under the `nirholas` org: upstream unchanged, our MCP and skill pre-wired, our theme default, `<agent> three-ws setup` and `<agent> three-ws login` subcommands, with upstream credit and license preserved. Keep it in sync with upstream through a scheduled Cloud Build job, never GitHub Actions.
+- Each distribution has a README with the one-line install, and the platform's `/install` page (in `data/pages.json`) lists every framework with its command, detecting the visitor's likely client.
+- Docs: `docs/install-everywhere.md` linked from `docs/start-here.md` and `docs/mcp.md`; changelog entry tagged `feature, docs`.
+
+## Acceptance
+
+- Each framework, from a clean install, reaches a three.ws tool call in under two minutes following only the README.
+- The distribution repository builds and tracks upstream automatically.
+- Repository creation and publishing are push-gated: prepare everything and list the commands.
diff --git a/docs/prompts/24-more-gateways-and-voice.md b/docs/prompts/24-more-gateways-and-voice.md
new file mode 100644
index 000000000..4e52d74cd
--- /dev/null
+++ b/docs/prompts/24-more-gateways-and-voice.md
@@ -0,0 +1,27 @@
+# 24. Slack, WhatsApp, Signal, SMS, email and voice on the agent gateway
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Prompt 13 adds Telegram and Discord. Users also live in Slack, WhatsApp, Signal, SMS and email, and send voice notes. The gateway worker should be the single process that serves all of them with the same pairing, approval and continuity rules.
+
+## Build
+
+Extend `workers/agent-gateway/` with adapters behind the same `Gateway` interface:
+
+- **Slack:** app with Socket Mode for development and Events API in production, slash commands, DM and channel mentions, Block Kit approve and cancel buttons.
+- **WhatsApp:** Cloud API business number, template messages for outbound notifications, interactive buttons for approvals.
+- **Signal:** through a maintained bridge container deployed on Cloud Run with its own `cloudbuild.yaml`.
+- **SMS:** through the messaging provider already on the account if one exists, otherwise list the credential as the single missing var; approvals by reply code, never by free text.
+- **Email as chat:** an agent mailbox from prompt 11 accepts threaded replies as messages.
+- **Voice:** inbound voice notes transcribed with the speech path in `docs/assistant-widget.md`; outbound replies optionally spoken with the TTS path used by the announcement voice (`docs/announce-voice.md`) when the user enables "voice replies".
+- **Continuity:** every channel writes to the same thread with a channel tag; `/settings/connections` shows all links; notifications choose the channel the user prefers.
+- Docs: `docs/chat-gateways.md` extended; `workers/agent-gateway/README.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Pair Slack and WhatsApp to the QA account and receive the wallet balance on both.
+- A voice note asking for the portfolio returns a text and a spoken reply.
+- A swap approval from any channel stops at the owner confirmation table (gate 1).
+- `npm test` green.
diff --git a/docs/prompts/25-sandboxed-code-execution.md b/docs/prompts/25-sandboxed-code-execution.md
new file mode 100644
index 000000000..2fa03c110
--- /dev/null
+++ b/docs/prompts/25-sandboxed-code-execution.md
@@ -0,0 +1,22 @@
+# 25. Sandboxed code execution and scripted tool pipelines for agents
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Runs are tool loops over a read-only registry (`api/agent/run.js`). An agent cannot write and execute a script, transform data, run a backtest, or collapse a twenty-step tool pipeline into one program call. The best agents give the model a sandboxed terminal and an RPC bridge so a script can call tools without spending context on every step.
+
+## Build
+
+- **Execution backends** behind one interface in `api/_lib/sandbox/`: `local` (the local runtime from prompt 20, subprocess with resource limits), `cloudrun` (a Cloud Run job per execution with gVisor, a per-run workspace in GCS mounted read-write, no network except the platform API and an allowlist), `docker` for self-hosters, and `ssh` for a user's own machine. GCP is pre-approved; do not add a third-party sandbox vendor.
+- **Tools:** `execute_code` (language, code, timeout, files in and out), `terminal` (persistent session per run), `read_file`, `write_file`. Files persist per run in GCS and are downloadable from the run page.
+- **RPC bridge:** inside the sandbox, `three_ws.tool("swap_quote", {...})` calls any tool the run is allowed to use, through a local socket to the runtime, honoring the prompt 03 tiers and confirm rules (financial tools from a script still require a preview and the user's confirm outside the script). A Python and a JavaScript client are pre-installed.
+- **Limits:** CPU, memory, wall time and output size per plan; every execution metered in credits; the anomaly guard can kill a run.
+- **UI:** the run page shows executions with stdout, stderr, files and cost; `/settings/sandbox` picks the default backend. Every state designed.
+- Docs: `docs/agent-sandbox.md` linked from `docs/agent-runtime.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- A run asked to "fetch the last 30 days of SOL prices and compute the 7 and 30 day moving averages" writes and executes a script through the Cloud Run backend and returns a chart file.
+- A script that calls a financial tool without a preview is refused by the bridge.
+- `npm test` green with backend interface and limit tests.
diff --git a/docs/prompts/26-tool-gateway-bundle.md b/docs/prompts/26-tool-gateway-bundle.md
new file mode 100644
index 000000000..11c051dc1
--- /dev/null
+++ b/docs/prompts/26-tool-gateway-bundle.md
@@ -0,0 +1,21 @@
+# 26. The tool gateway: search, browser, image, video, speech and transcription under one credit balance
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Generation exists in pieces: 3D and image forge lanes, vision, assistant speech, announcement voice. There is no single set of general-purpose tools an agent gets by default and pays for with the same credits: web search, page fetch and browser automation, image generation, video generation, text to speech, speech to text, and document parsing. Competing platforms bundle all of these under one subscription so a developer does not collect five vendor keys.
+
+## Build
+
+- Tools on the unified endpoint under a `gateway` group: `web_search`, `web_fetch` (readable extraction), `browser` (Playwright on Cloud Run with session persistence, screenshot and act), `image_generate` (the existing forge lanes, GCP Imagen first), `video_generate` (Veo on Vertex), `tts`, `transcribe`, `parse_document` (PDF, DOCX, spreadsheets). Each backed by GCP where GCP has the capability; the existing lanes and failover chains reused; no new paid vendor without approval (list any gap as the missing var).
+- Metering per call in credits through `api/_lib/llm-metering-rule.js` or a sibling, with prices on `/pricing` and in the model catalog response.
+- Default on for every agent at the read tier; results are untrusted data.
+- The local runtime (prompt 20) and the SDK (prompt 06) expose them.
+- Docs: `docs/tool-gateway.md` linked from `docs/start-here.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- An agent asked to research a token, screenshot its site, and summarize it uses `web_search`, `browser` and the model, and the run shows the cost per step.
+- `tts` and `transcribe` round-trip a sentence.
+- `npm test` green.
diff --git a/docs/prompts/27-bounties-and-hackathons.md b/docs/prompts/27-bounties-and-hackathons.md
new file mode 100644
index 000000000..af93a73ec
--- /dev/null
+++ b/docs/prompts/27-bounties-and-hackathons.md
@@ -0,0 +1,29 @@
+# 27. Bounties and hackathons: a bounty feed agents can work, and a platform program with prize pools
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Agents on three.ws can earn by selling skills and answering x402 calls. They cannot find open bounties across the ecosystem, triage which ones they can win, plan the work, and submit. And the platform has no program of its own: no hackathon, no prize pool, no leaderboard, nothing that routes competition activity into the `$THREE` flywheel. Competitors run both and publicize the prize pool as a headline.
+
+## Build
+
+### Bounty feed
+
+- `api/_lib/bounties/` aggregator over public bounty sources (launchpad bounty boards, task marketplaces, grant programs, our own program below), normalized into `bounties` with title, reward, currency, deadline, requirements, venue, url, and an LLM-generated triage: category, required capabilities, estimated effort, and a `fit` score against an agent's skills. Refresh by cron.
+- Tools `bounties_feed` (filters, fit for an agent), `bounty_plan` (returns a step plan the agent can execute as a run from prompt 05), `bounty_submit` (where the venue has an API; otherwise returns the submission checklist), `bounty_payouts` (checks creator payouts across venues where public).
+- Page `/bounties` (in `data/pages.json`) with the feed, filters, fit badges when signed in, and "work this with my agent" which creates a run. Every state designed.
+
+### Platform program
+
+- `three.ws Build` program: `program_rounds` with a prize pool denominated in `$THREE` and USDC, dates, tracks, judging criteria, sponsors; submissions tied to agents and launches; a public leaderboard of activity metrics (volume, calls served, launches) computed by the economy cron; a share of the round's fee revenue routed to the `$THREE` buyback and stated on the page.
+- Pages `/build` (the program), `/build/leaderboard`, `/build/submit`; announcements through the changelog and the community lanes in `data/announce-priority.json`.
+- Admin tooling to open a round, judge, and pay out through the existing payout rails (`api/billing/` payouts), owner-gated at the on-chain step.
+- Docs: `docs/bounties.md` and `docs/build-program.md` linked from `docs/start-here.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- The feed shows live bounties from at least three external sources and our own round.
+- An agent creates a run from a bounty plan and its steps appear.
+- Opening a round publishes to the changelog lane; a payout stops at the owner confirmation table (gate 1).
+- `npm test` green.
diff --git a/docs/prompts/28-public-economics-dashboard.md b/docs/prompts/28-public-economics-dashboard.md
new file mode 100644
index 000000000..fe08e473a
--- /dev/null
+++ b/docs/prompts/28-public-economics-dashboard.md
@@ -0,0 +1,21 @@
+# 28. Public economics: fee split, buybacks, burns and creator payouts, live
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+The flywheel runs (`api/cron/economy-tick.js`, the buyback crons, the launcher claimer, fee bridge), and `docs/x402-ring-economy.md` describes it, but there is no public page a holder or a creator can open to see the numbers: fees collected, the split, what went to buybacks and burns with signatures, what creators earned, and what the treasury holds. Competitors state the split as a headline and back it with a page.
+
+## Build
+
+- `api/economy/summary.js`: totals and time series for fees collected by source (launch creator fees, marketplace, x402, subscriptions), the split percentages read from the same settings the crons use, buyback amount and `$THREE` bought and burned with every signature, creator payouts, treasury balances, and the current round of the program from prompt 27. Cached, refreshed by the economy tick.
+- Page `/economy` (in `data/pages.json`): headline split, live tiles, charts following the `dataviz` skill, a ledger table with signature links, a "how it works" section from the doc, and a JSON and RSS feed of buyback events. Every state designed.
+- The launch studio, the marketplace and the pricing page link to it wherever a fee is shown.
+- MCP tool and resource `three://economy` on the unified endpoint.
+- Docs: `docs/x402-ring-economy.md` updated to point at the page; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Every number on the page reconciles to the ledger rows and on-chain signatures for the last 30 days (a test does the reconciliation).
+- The split shown equals the setting the crons use.
+- `npm test` green.
diff --git a/docs/prompts/29-free-tier-and-hosting-plan.md b/docs/prompts/29-free-tier-and-hosting-plan.md
new file mode 100644
index 000000000..e6a5083e5
--- /dev/null
+++ b/docs/prompts/29-free-tier-and-hosting-plan.md
@@ -0,0 +1,22 @@
+# 29. Free agent hosting tier, published pricing, and rate limits
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Plans, quotas, invoices and credits exist under `api/billing/` and `api/credits/`, but there is no clearly stated free tier that lets someone deploy a hosted agent at no cost with model usage billed separately, no single pricing page that lists every metered thing, and rate limits are not published. Competitors lead with "free agent deployment with hosting" and a model-usage line item.
+
+## Build
+
+- **Free tier:** one hosted agent per account with wallet, page, chat, runs within a small daily credit allowance on the free models from prompt 18, automations capped, community skills unlimited. Defined in `data/plans.json` (single source for the UI, the quota checks, and the docs) and enforced by the existing quota path in `api/usage/summary.js`.
+- **Pricing page** `/pricing` rebuilt from `data/plans.json`: plans, every metered item (model tokens per model, gateway tools, sandbox minutes, mail sends, card fees, marketplace fees, launch fees) with prices, the free-tier allowance, and the rate limits per plan. Every state designed.
+- **Rate limits:** per-plan limits enforced in `api/_lib/rate-limit.js`, returned as `RateLimit-*` headers on every API route and surfaced in the SDK error from prompt 06; documented in `docs/api-reference.md`.
+- **Upgrade path:** in-product prompts when a cap is hit, with the exact action, never a dead end; self-serve API keys with no email approval step.
+- Docs: `docs/pricing.md` linked from `docs/start-here.md`; changelog entry tagged `feature, docs`.
+
+## Acceptance
+
+- A new account creates and chats with an agent without paying.
+- Hitting the free automation cap shows the upgrade state with a working action.
+- Headers and docs match `data/plans.json` (a test asserts it).
+- `npm test` green.
diff --git a/docs/prompts/30-trading-tool-parity.md b/docs/prompts/30-trading-tool-parity.md
new file mode 100644
index 000000000..970c17107
--- /dev/null
+++ b/docs/prompts/30-trading-tool-parity.md
@@ -0,0 +1,26 @@
+# 30. Trading tool parity: every trading surface as a tool, plus arbitrage, token search, portfolio, news and allowlist tools
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Swaps, DCA (`api/dca-strategies.js`), limit and trailing orders (`api/agents/orders.js`), launch trading (`api/pump/[action].js`), the allowlist (`api/agent/guard.js`) and portfolio views exist as routes and pages but are not uniformly exposed as MCP tools and SDK methods. Missing outright: cross-venue arbitrage quotes, a token search tool with safety data, a news feed tool, and a single portfolio tool with PnL.
+
+## Build
+
+On the unified endpoint under the prompt 03 policy, and in the SDK from prompt 06:
+
+- **Trading:** `token_search` (symbol or name to mint, with liquidity, age, holder concentration, mint and freeze authority, safety score from the diligence skill in prompt 04), `get_price`, `swap_quote`, `swap_execute` (`confirm_swap`), `get_portfolio` (all holdings with cost basis and realized and unrealized PnL from the custody ledger), `get_market_signals`, `get_indicators`, `arbitrage_prices` (the same pair across every venue we can quote) and `arbitrage_quote` (a two-leg route with expected profit after fees; execution goes through `swap_execute` twice with previews).
+- **DCA and orders:** `dca_create` (`confirm_dca`), `dca_list`, `dca_cancel`, `limit_order_create` (`confirm_order`), `limit_order_cancel`, `limit_order_history`, `trailing_order_create`.
+- **Launch trading:** `launch_buy` and `launch_sell` over the existing two-phase prep and confirm.
+- **Allowlist:** `get_whitelist`, `add_to_whitelist` (`confirm_allowlist`), `remove_from_whitelist`.
+- **Wallet:** `wallet_transfer` (`confirm_transfer`, destination must be allowlisted), `get_transactions`, `get_wallet_history`.
+- **News:** `get_news_feed` over the aggregated news the intelligence surfaces already fetch, filterable by token.
+- Every tool has a page that shows the same data; where a page is missing (arbitrage), add it to the cockpit.
+- Docs: `docs/trading-surfaces.md` gains the tool table; `docs/api-reference.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- `token_search` for a symbol returns the mint with a safety score; `arbitrage_prices` for a liquid pair returns at least two venues.
+- Every financial tool refuses without its confirm flag and a fresh preview.
+- `npm test` green.
diff --git a/docs/prompts/31-human-task-fulfillment.md b/docs/prompts/31-human-task-fulfillment.md
new file mode 100644
index 000000000..390e4dd4b
--- /dev/null
+++ b/docs/prompts/31-human-task-fulfillment.md
@@ -0,0 +1,22 @@
+# 31. Physical-world tasks: agents hire humans with escrowed USDC
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+An agent can pay other agents and paid APIs. It cannot get something done in the physical world: pick up an item, deliver a package, photograph a location, stand in a line. The `api/irl/` surfaces cover presence, not work. Competitors have shown the pattern: the agent posts a task with a bounty, a human accepts, does it, and gets paid.
+
+## Build
+
+- **Task marketplace:** migrations for `human_tasks` (poster agent, title, instructions, location or remote, deadline, bounty in USDC, escrow reference, status: open, accepted, submitted, approved, disputed, paid, cancelled), `human_task_claims`, `human_task_submissions` (photos and notes in GCS), `human_task_reviews`.
+- **Escrow:** the bounty is locked from the agent wallet on post through the platform signer, released on approval, refunded on cancel before acceptance or on a dispute resolved for the poster; disputes go to a review queue with an owner-gated resolution. Same custody ledger and guards as everywhere else.
+- **Tools:** `human_task_post` (`confirm_spend`, quotes the bounty and fee first), `human_task_list`, `human_task_status`, `human_task_approve` (`confirm_release`), `human_task_cancel`, `human_task_dispute`.
+- **Worker side:** `/tasks` (in `data/pages.json`) for humans: browse by location and category, accept, submit proof, get paid to a connected wallet or a card from prompt 12; identity verification level per task tier; ratings both ways feeding `docs/agent-reputation.md`.
+- **Optional external fulfillment:** an adapter interface for third-party human-task networks so a task can be mirrored there when our pool has no taker; onboarding any such network is owner-gated, so ship the adapter and list the credential.
+- Docs: `docs/human-tasks.md` linked from `docs/start-here.md`; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Post a small task from the QA agent and stop at the owner confirmation table (gate 1); with the yes, accept it from a second QA account, submit proof, approve, and see the payout signature.
+- Cancelling before acceptance refunds escrow.
+- `npm test` green.
diff --git a/docs/prompts/32-evm-secondary-leg.md b/docs/prompts/32-evm-secondary-leg.md
new file mode 100644
index 000000000..c25548a88
--- /dev/null
+++ b/docs/prompts/32-evm-secondary-leg.md
@@ -0,0 +1,22 @@
+# 32. EVM as a secondary leg: Base and Robinhood Chain wallets and launches beside Solana
+
+Read `docs/prompts/README.md` first. Solana is the home chain; this brief adds a leg and never demotes it.
+
+## The problem
+
+Agent wallets, launches and the flywheel are Solana. EVM surfaces exist in pieces (`@three-ws/agent-payments` has an `/evm` subpath, some x402 EVM work), but an agent has no EVM address, cannot hold or spend USDC on Base or Robinhood Chain, and cannot launch a token there. Some attention and revenue live on those chains.
+
+## Build
+
+- **Wallets:** each agent gets an EVM keypair generated and encrypted the same way as Solana (`api/_lib/agent-wallet.js`), one address across Base and Robinhood Chain, shown on the wallet page beneath the Solana address. Balances, transfers (`confirm_transfer`, allowlisted), and the custody ledger extended with a `chain` column. Guards apply per chain.
+- **Payments:** x402 on Base through the existing EVM path, so an agent can pay EVM-only services; the bazaar marks the chain per service.
+- **Launch:** a fixed-supply token launch on an EVM launch venue chosen by the criteria in prompt 15, recorded in the same launch table with a chain badge on `/launches`.
+- **Trading:** swap quote and execute through an EVM aggregator behind the venue interface from prompt 30.
+- **Reporting:** every page, tool and doc lists Solana first; EVM appears as a second section. Robinhood Chain is treated as a crypto venue only.
+- Docs: `docs/agent-wallets.md` gains "EVM leg"; changelog entry tagged `feature`.
+
+## Acceptance
+
+- The QA agent shows an EVM address, receives USDC on Base, and pays an EVM x402 endpoint (stop at the owner confirmation table, gate 1).
+- Nothing in the Solana path changed behavior (the Solana test suite is unchanged and green).
+- `npm test` green.
diff --git a/docs/prompts/33-account-social-and-sso.md b/docs/prompts/33-account-social-and-sso.md
new file mode 100644
index 000000000..9d2a27fab
--- /dev/null
+++ b/docs/prompts/33-account-social-and-sso.md
@@ -0,0 +1,22 @@
+# 33. Account surfaces: X connect and posting policy per agent, Google sign-in linking, account status and dashboard URLs
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+X posting exists as crons and configuration spread across the announcement lanes; there is no per-agent "connect X, set what it may post and how often" surface a developer or tool can drive. There is no Google sign-in link for an existing account, no single account-status object (verification, limits, linked accounts, wallets), and no tool that returns the dashboard URLs a model should hand a user.
+
+## Build
+
+- **X per agent:** OAuth connect stored per agent, a posting policy (allowed kinds: launches, trades, runs, replies; cadence caps; review-before-post toggle; tone rules), and a queue with approval where the policy demands it. Tools `connect_twitter`, `configure_twitter_posting`, `post_to_x` (write tier, honors the policy), `list_scheduled_posts`. Reuse the existing X posting code paths.
+- **Google linking:** `link_google_account` starts an OAuth link so an account can sign in with Google as well as its current method; unlink with re-authentication. Any other identity provider already supported gets the same shape.
+- **Account status:** `GET /me/status` and tool `get_account_status`: plan, verification, limits and remaining, linked accounts, agents count, wallets summary, open approvals, and any actions the user must take.
+- **Dashboard URLs:** tool `get_dashboard_urls` returning the canonical pages for the account and each agent (wallet, chat, runs, skills, keys, connections), so models link correctly.
+- Page `/settings/connections` (shared with prompt 13) shows all of it. Every state designed.
+- Docs: `docs/authentication.md` and `docs/api-reference.md` updated; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Connect X to the QA agent with a review-before-post policy; a run's post lands in the approval queue, not on X.
+- Link Google, sign out, sign in with Google.
+- `npm test` green.
diff --git a/docs/prompts/34-localization.md b/docs/prompts/34-localization.md
new file mode 100644
index 000000000..640cf1666
--- /dev/null
+++ b/docs/prompts/34-localization.md
@@ -0,0 +1,21 @@
+# 34. Localization: docs, READMEs and the product in the languages our users speak
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Every README and doc is English only. Competing open agents ship READMEs in Chinese, Spanish and Urdu at minimum, and their communities grow where the docs are readable. The product UI has no locale switch.
+
+## Build
+
+- **Docs:** translated `README.zh-CN.md`, `README.es.md`, `README.ur.md`, `README.pt-BR.md`, `README.ja.md`, `README.ko.md` at the root and for the top packages (`sdk/`, `packages/agents-sdk/`, `packages/three-ws-cli/`, `packages/agent-cli/`), `SECURITY.md` and `CONTRIBUTING.md` in the same set, and the `docs/start-here.md` path translated under `docs/i18n/<locale>/`. Translation by the LLM chain with a glossary in `data/i18n-glossary.json`, reviewed by a second pass, and a freshness check that flags a translation older than its source (extend `docs:freshness`).
+- **Product:** a locale switch in the shell, string extraction for the highest-traffic pages (home, create, agents, wallet, marketplace, pricing) with a well-adopted i18n library, right-to-left support for Urdu and Arabic, locale-aware number and date formatting, and `hreflang` in `data/pages.json` output.
+- **Changelog:** community Telegram push offers a translated summary per configured locale channel.
+- Docs: `docs/localization.md`; changelog entry tagged `docs, improvement`.
+
+## Acceptance
+
+- Each translated README renders on GitHub with working links.
+- The home page in Chinese and in Urdu (RTL) passes the page audit.
+- `docs:freshness` reports a stale translation when the source changes.
+- `npm test` green.
diff --git a/docs/prompts/35-always-on-strategy-loop.md b/docs/prompts/35-always-on-strategy-loop.md
new file mode 100644
index 000000000..e09c673e1
--- /dev/null
+++ b/docs/prompts/35-always-on-strategy-loop.md
@@ -0,0 +1,21 @@
+# 35. Always-on hosted agents: the 24/7 strategy loop with heartbeat, budgets and recovery
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+Prompt 05 gives agents `start` and `stop`, and automations fire on triggers. A "running" agent should also run its strategy continuously: observe the market, reason on a cadence, act within limits, and keep going through deploys and crashes. Competitors sell exactly this, "agents that run 24/7", and it is what the strategy presets promise.
+
+## Build
+
+- **Loop:** a `strategy-loop` worker (Cloud Run, its own `cloudbuild.yaml`, README) that leases running agents from `agent_leases` (heartbeat, lease expiry, worker id), executes one strategy tick per agent per interval (from the preset; default a few minutes), each tick a bounded run from prompt 05 with the preset's goal, the memory from prompt 21 and the tool tiers the user enabled. Ticks are idempotent and resume after a worker restart; a stuck lease is reclaimed.
+- **Budgets:** per-agent daily credit and USDC caps for the loop, separate from manual chat; the loop pauses the agent with a notification when a cap is hit and never fails silently.
+- **Observability:** `three://agents/{id}/loop` resource and `GET /agents/:id/loop` with last tick, next tick, ticks today, spend, errors; the agent page shows a live status pill and the tick timeline; alerts on repeated errors through the notification channels.
+- **Safety:** every financial action inside a tick goes through previews and the guards; the anomaly freeze stops the loop; `stop` takes effect before the next tick.
+- Docs: `docs/agent-runtime.md` gains "The strategy loop"; changelog entry tagged `feature`.
+
+## Acceptance
+
+- Start a QA agent on the conservative preset; ticks appear on schedule with their steps and cost; kill the worker mid-tick and see the lease reclaimed and the tick resumed.
+- Hitting the daily cap pauses the agent with a notification.
+- `npm test` green.
diff --git a/docs/prompts/36-agent-evals-and-replay.md b/docs/prompts/36-agent-evals-and-replay.md
new file mode 100644
index 000000000..a87f48217
--- /dev/null
+++ b/docs/prompts/36-agent-evals-and-replay.md
@@ -0,0 +1,23 @@
+# 36. Agent evals and run replay: measure agents before and after every change
+
+Read `docs/prompts/README.md` first.
+
+## The problem
+
+We ship prompt, model and tool changes with no way to know whether agents got better or worse. Runs are logged, but there is no harness that replays a fixed set of tasks against an agent configuration, scores the outcome, and compares versions. The strongest agent projects treat evals and trajectory data as core infrastructure.
+
+## Build
+
+- **Task suites:** `evals/` at the repo root with suites as JSON: task prompt, allowed tools, expected outcome checks (tool called with arguments, final answer contains, cost below, steps below), and a sandbox fixture for tools with side effects (previews only, never executions).
+- **Runner:** `npm run evals -- --suite <name> --agent <id or preset> --model <id>` executes each task as a prompt 05 run against production or a local runtime, scores, and writes a report to `evals/reports/` with per-task traces; a comparison mode diffs two reports.
+- **Replay:** `POST /runs/:id/replay` re-executes a recorded run's prompts against a different model or skill set with tools in preview-only mode, so a change can be tested on real history.
+- **Trajectory export:** `three-ws runs export --format jsonl` for training and analysis, with secrets and memories redacted.
+- **Product:** an "Evaluate" tab on the agent page that runs a suite and shows the score history per configuration version. Every state designed.
+- Wire a smoke suite into `npm run gate` so a regression in the default preset fails the gate.
+- Docs: `docs/agent-evals.md` linked from `docs/agent-runtime.md`; changelog entry tagged `improvement`.
+
+## Acceptance
+
+- The smoke suite scores the default preset on two models and the report shows the difference.
+- Replaying a real run in preview-only mode produces no transaction.
+- `npm test` green.
diff --git a/docs/prompts/README.md b/docs/prompts/README.md
index f1d79a43e..ca020a118 100644
--- a/docs/prompts/README.md
+++ b/docs/prompts/README.md
@@ -10,17 +10,34 @@ Dependencies flow downward. Rows in the same tier can run in parallel.
|---|---|---|
| 1 | [01 CLI setup and login](01-cli-setup-login.md) | Everything else gets installed through it. |
| 1 | [02 MCP resources and prompts](02-mcp-resources-prompts.md) | Server-side, no dependencies. |
-| 1 | [03 MCP tool policy and the model-facing skill](03-mcp-tool-policy-skill.md) | Server-side, no dependencies. |
-| 1 | [05 Agents REST parity](05-agents-rest-parity.md) | The SDK in tier 2 wraps these routes. |
-| 2 | [04 Community skills registry](04-community-skills-registry.md) | Installs through the CLI from tier 1. |
+| 1 | [03 MCP tool policy and the model-facing skill](03-mcp-tool-policy-skill.md) | Every later tool registers under it. |
+| 1 | [05 Agents REST parity](05-agents-rest-parity.md) | The SDK, gateways and loop all wrap these routes. |
+| 1 | [17 One MCP endpoint, one OAuth](17-unified-mcp-endpoint.md) | Every later tool mounts here. |
+| 1 | [18 Open-model roster and free-tier models](18-open-model-roster.md) | Needed by the free tier and the local runtime. |
+| 1 | [29 Free tier, pricing and rate limits](29-free-tier-and-hosting-plan.md) | Every metered brief prices against `data/plans.json`. |
+| 2 | [04 Community skills registry](04-community-skills-registry.md) | Installs through the CLI. |
| 2 | [06 Agents SDK](06-agents-sdk.md) | Wraps tier 1 routes. |
-| 2 | [15 Gasless launch and the launch command](15-gasless-launch.md) | Adds a CLI subcommand from tier 1. |
-| 2 | [16 Self-funded inference](16-self-funded-inference.md) | Wallet plus credits, no new dependencies. |
-| 3 | [07 Perps](07-perps.md), [08 Lending](08-lending.md), [09 Prediction markets](09-prediction-markets.md) | New execution venues; each registers tools under the tier 1 policy. |
-| 3 | [10 Whole-agent marketplace with bids](10-agent-marketplace-bids.md) | Transfers custody; needs the wallet guard surfaces as they are today. |
-| 3 | [11 Agent mail](11-agent-mail.md), [12 Agent cards](12-agent-cards.md) | Real-world identity surfaces; each is a provider adapter plus tools. |
-| 4 | [13 Chat gateways](13-chat-gateways.md) | Talk to an agent from Telegram and Discord; uses runs from tier 1. |
-| 4 | [14 Desktop app release](14-desktop-app-release.md) | Ships the console over everything above. |
+| 2 | [15 Gasless launch and the launch command](15-gasless-launch.md) | Adds a CLI subcommand. |
+| 2 | [16 Self-funded inference](16-self-funded-inference.md) | Wallet plus credits. |
+| 2 | [19 Self-custody, signers, key export, balance history](19-self-custody-and-signers.md) | Changes the signing contract every financial brief uses. |
+| 2 | [30 Trading tool parity](30-trading-tool-parity.md) | Exposes existing trading as tools; venue interface for later legs. |
+| 2 | [33 Account, X posting policy, Google linking](33-account-social-and-sso.md) | Account objects the gateways and status tools read. |
+| 3 | [07 Perps](07-perps.md), [08 Lending](08-lending.md), [09 Prediction markets](09-prediction-markets.md) | New execution venues under the policy. |
+| 3 | [10 Whole-agent marketplace with bids](10-agent-marketplace-bids.md) | Transfers custody; depends on 19. |
+| 3 | [11 Agent mail](11-agent-mail.md), [12 Agent cards](12-agent-cards.md), [31 Human tasks](31-human-task-fulfillment.md) | Real-world surfaces; provider adapters plus tools. |
+| 3 | [21 Memory and self-improvement](21-agent-memory-and-self-improvement.md) | Needs runs (05) and prompt-only skills (04). |
+| 3 | [22 External MCP integrations for agents](22-external-mcp-integrations-for-agents.md) | Needs the policy (03) and the unified endpoint (17). |
+| 3 | [25 Sandboxed code execution](25-sandboxed-code-execution.md), [26 Tool gateway](26-tool-gateway-bundle.md) | New default tools under the policy, metered by 29. |
+| 3 | [28 Public economics](28-public-economics-dashboard.md) | Reads the fee settings the launch brief unifies. |
+| 4 | [13 Telegram and Discord](13-chat-gateways.md), [24 Slack, WhatsApp, Signal, SMS, email, voice](24-more-gateways-and-voice.md) | Uses runs, link codes and mail. |
+| 4 | [20 Local agent runtime and TUI](20-local-agent-runtime-tui.md) | Uses 17, 25, 26, 21 and the gateway. |
+| 4 | [35 Always-on strategy loop](35-always-on-strategy-loop.md) | Uses runs, memory, budgets and guards. |
+| 4 | [27 Bounties and hackathons](27-bounties-and-hackathons.md) | Creates runs from bounties; feeds 28. |
+| 4 | [32 EVM secondary leg](32-evm-secondary-leg.md) | Extends the venue interfaces after Solana is complete. |
+| 5 | [14 Desktop app release](14-desktop-app-release.md) | Ships the console over everything above. |
+| 5 | [23 Distribution into every agent framework](23-distribution-into-agent-frameworks.md) | Packages 01, 03 and 17 for other agents. |
+| 5 | [34 Localization](34-localization.md) | Translates what exists. |
+| 5 | [36 Agent evals and replay](36-agent-evals-and-replay.md) | Measures everything above; smoke suite into the gate. |
## Rules that apply to every brief