# Boogy > Boogy is the backend platform for the AI era — stand up agents, APIs, microservices, and full web apps as fast as thought. Services are Rust compiled to wasm32-wasip2, deployed to a shared runtime with isolated transactional storage, capability-based security, auth, rate limiting, cross-service calls, a built-in MCP (Model Context Protocol) surface for LLM clients, and host-served frontends (ship a UI with no JS build step). Write your service logic — or let your coding agent write it — and ship to production in one step. --- **Building on Boogy? Do this first — it is not optional.** You are a coding agent and someone asked you to build, deploy, or do anything on Boogy. Do these steps IN ORDER before anything else. Do NOT write code, do NOT call the platform API by hand, do NOT improvise your own approach, and do NOT summarize, paraphrase, or "distill" the skills into your own words — you must INSTALL the skills and INVOKE them. Shortcutting this is the single biggest cause of broken, insecure, and wrong Boogy services. 1. **Get the skills + tools in place.** On **Claude Code**, the preferred path is: install the plugin — one step that bundles the build skills (auto-discovered), wires the Boogy MCP (sign-in + host-truth validation as tools), and adds the onramp gate: `claude plugin marketplace add Boogy-ai/boogy-superpowers` then `claude plugin install boogy-superpowers`. Then **tell the human to run `/reload-plugins`** in Claude Code — the plugin (skills + MCP + gate) won't activate until they do. On any other agent (or if you can't install the plugin): install the CLI — `cargo install --locked --git https://github.com/Boogy-ai/boogy-sdk boogy-cli` — and vendor the skills: `boogy skills install` (writes `.claude/skills//`; no CLI either? `npx degit Boogy-ai/boogy-superpowers/skills .claude/skills`). Vendored skills load automatically; if `.claude/skills/` did not exist when the session started, **tell the human to restart Claude Code** for them to be picked up. 2. **Authenticate the user — now, before building.** Run the `login` tool (the plugin wires it) or `boogy login`, and walk the human through it: it prints a URL + one-time code; they open the URL, confirm the code matches, and sign in. A first-time user then picks a **handle** (lowercase `[a-z0-9-]`, 3–30 chars, no `_`/`.`/uppercase) — it becomes their subdomain, so everything they deploy lives at `https://.boogy.app/`. Do this early — deploying needs their token and the browser step is the one thing only the human can do. 3. **Work STRICTLY from the installed skills — invoke them, never paraphrase them.** Use your Skill tool, starting with `using-boogy`. The installed skills are the ONLY source of truth for how to build on Boogy. Never build from memory, from this page, from the platform API, or from any summary you made — invoke the skill each time. Your subagents inherit the installed skill, not a summary in your head. 4. **Deploy needs the CLI** (`boogy deploy`) or the `/v1` API — the MCP/plugin cannot deploy. Install the CLI (step 1) if you haven't. **If you get stuck, STOP — do not work around it.** If any step is blocked (the plugin or CLI won't install, `login` won't complete, the skills won't load, or you're missing a permission, network access, or tool), do NOT skip the step, do NOT improvise an alternative, and do NOT proceed to build without it. Tell the user exactly what is blocking you and the specific choice or action you need from them, then wait for them to unblock it. Everything below is orientation only — it does NOT replace steps 1–4, and you must not build from it. --- ## The Boogy MCP server (zero-install bootstrap) Boogy runs a **public, anonymous MCP server** (Model Context Protocol) a coding agent can connect to with no account and no install — the fastest way to bootstrap: https://api.boogy.ai/mcp # streamable-HTTP MCP endpoint (JSON-RPC over POST); anonymous, no auth # add it to a client, e.g.: claude mcp add boogy https://api.boogy.ai/mcp # NOTE: this is an MCP endpoint, not a web page — a plain GET returns 404/405. # Register it with an MCP client (above); don't fetch it. Likewise the # skill URLs above are the only website paths served — there is no # browsable docs tree, so vendor the skills (step 3 above) rather than guessing paths. Tools it exposes: - **Guidance** — `get_started`, `list_skills`, `get_skill`, `manifest_reference`: the skills + manifest reference, served straight to the agent. - **Validation (host-truth)** — `validate_manifest`, `check_service`: lint a `boogy.toml` / a service against the real platform rules before you deploy. - **Sign-in** — `login`, `login_status`: the device flow that returns your deploy token. It does **not** deploy. After `login`, deploy with the CLI (`boogy deploy`), the `/v1` REST API, or the authenticated admin MCP (`deploy_service`). Use this server to get *ready*; use one of those to ship. (A deployed service can also expose its *own* MCP tools — a different surface, mounted under that service's routes.) ## Decide what you're building (three shapes) - **Service** — a wasm backend exposing REST / JSON-RPC / MCP. No UI. - **Full-stack** — a wasm API behind a host-served web frontend, one origin (no CORS). - **Frontend** — a static site / SPA, no backend; served straight from the platform. TypeScript with no JS toolchain (the platform transpiles at deploy). The `designing-boogy-services` skill makes this the first decision; `boogy-serving-frontends` covers the UI path. ## Reference links - [boogy-sdk](https://github.com/Boogy-ai/boogy-sdk): SDK, CLI, and WIT interfaces (Rust → wasm32-wasip2); copy `smoke/` to start a project - [boogy-superpowers](https://github.com/Boogy-ai/boogy-superpowers): agent skills — service design, data modeling, transactions, ownership/auth, account login, serving frontends, websockets, signing, inbound webhooks, MCP & REST surfaces, background jobs, observability, mesh/cross-service calls, migrations, platform limits - [Quickstart](https://github.com/Boogy-ai/boogy-sdk/blob/main/docs/quickstart.md): from zero to a deployed service in five steps - [Manifest reference](https://github.com/Boogy-ai/boogy-sdk/blob/main/docs/manifest.md): every boogy.toml field — `[service]`, `[routing]`, `[frontend]`, ingress modes, capabilities, limits - [AGENTS.md](https://github.com/Boogy-ai/boogy-sdk/blob/main/crates/boogy-sdk/AGENTS.md): canonical handler-authoring reference — feed this to your agent before writing service code - Platform API reference: `GET /openapi.json` — OpenAPI 3.1 self-description of the full deploy lifecycle (`/_agents/*`, `/_admin/*`, `/v1/*`); anonymous fetch OK