---
name: choose-your-plungeai-door
description: "Picks the right PlungeAI entry point before you write anything — the MCP server (https://mcp.plungeai.com/v1) for live agent operation, the One API (https://api.plungeai.com) for code you write or generate, the Ocean CLI for a terminal or CI workflow, or Ocean Studio for a human building visually — and names the setup or capability skill to load next. Use when the user asks which PlungeAI door, API, or interface to use, says \"how do I use PlungeAI\", \"what's the difference between the MCP server and the One API\", asks \"does PlungeAI have a CLI/SDK/UI\", or is choosing between MCP, REST, CLI, and Studio before writing any code. For the mechanics once a door is picked, use `plungeai-mcp-setup` (MCP), `plungeai-api-setup` (REST/codegen), or `plungeai-cli-setup` (terminal); for wiring a specific coding tool's agent to PlungeAI use `plungeai-in-<tool>`; the full capability map lives in `plungeai-platform`."
---

# Choose your PlungeAI door

PlungeAI (internally "Ocean") is a Cloudflare-native agent runtime: every agent, tool, and
workflow runs as a deployed edge service. There is no local mode — everything you execute
runs on the deployed platform, and everything you read (catalogs, contracts, results) is
live. You reach it through one of four doors, all backed by the same identity and the same
data (a workflow saved through one door appears in every other door and in Studio).

## The four doors

| Door | What it is | Use it when |
|---|---|---|
| **MCP server** — `https://mcp.plungeai.com/v1` | The `plungeai_*` tool suite over MCP (Streamable HTTP) | You are an AI agent operating the platform live in a chat/agent context: discover, execute, save, schedule, remember. The richest surface — structured outcomes, approvals, continuations. |
| **One API** — `https://api.plungeai.com` | REST gateway, OpenAPI 3.1 at `GET /v1/openapi.json` | You are writing or GENERATING code that calls PlungeAI: apps, scripts, backends, CI jobs, SDK wrappers. |
| **Ocean CLI** — `ocean` | Terminal client (not yet on npm — install from the Ocean-Platform repo, or your administrator's build) | A human (or a script) works from a shell or CI pipeline: auth, doctor, running saved flows, scheduling. |
| **Ocean Studio** | Browser app at `https://studio.plungeai.com` | A human builds/edits workflows visually, reviews runs, connects OAuth credentials, configures schedules — anything a door refuses (credential connect, OAuth, visual editing). |

## Rules of thumb

- **Operating live from a chat/agent context → MCP.** One tool call per intent; the platform
  renders final user-ready markdown — relay it verbatim. Setup: `plungeai-mcp-setup`.
- **Generating code for a user's project → One API.** Point codegen at
  `GET /v1/openapi.json`; never invent routes. Setup: `plungeai-api-setup`.
- **A human or CI script driving a terminal → Ocean CLI.** Setup: `plungeai-cli-setup`.
- **Anything a door refuses (credential connect, OAuth, visual editing) → send the user to
  Ocean Studio.** No skill needed — it's a browser app.
- **Connecting a *specific* coding tool's agent** (Cursor, VS Code, Claude Code, Codex,
  Windsurf, Replit, Gemini CLI, OpenCode, Lovable, Bolt, v0, …) rather than deciding which
  door in the abstract → jump straight to that tool's `plungeai-in-<tool>` skill; it tells
  you which door that tool uses and gives the exact config.
- Same identity behind every door: an `ozk_` key on MCP and the One API, a Studio session
  cookie (or the same `ozk_` key for key-side verbs) on the CLI.

## Get a key first

Self-service `ozk_` keys: **Dashboard → One API → Keys** (`https://dashboard.plungeai.com`) →
create → copy it once (shown only at creation). Ask the account owner only if you need a
shared team key minted under someone else's account. The same key works on MCP and the One
API; the Ocean CLI additionally takes a Studio session cookie for its browser-only surfaces
(saved flows, schedules, registry browse).

## Which capability for which job

Once you know your door, `plungeai-platform` is the full capability map. Quick router:

- **One-shot capability call** ("search the web", "convert this PDF") → `plungeai-agents`
  (prompt-driven) or `plungeai-tools-connectors` (structured, typed params).
- **Multi-step pipeline** ("research A, B, C in parallel, then synthesize") → CNL workflow,
  author it with `plungeai-workflows`.
- **Open-ended goal needing judgment** ("investigate X, use whatever tools you need") → one
  bounded harness mission, `plungeai-missions`.
- **"Every morning / every hour" anything** → `plungeai-scheduling`.
- **Long-running lead-gen / outreach style batches** → `plungeai-campaigns`.
- **Instruction packs injected into a run** (skills, plugins, experts, personas) →
  `plungeai-skills-plugins`.
- **"Remember this" / long-term memory** → `plungeai-memory`.
- **Raw LLM inference in your own code** (chat/embeddings, model fallback) → `plungeai-models`.
- **"What can PlungeAI do" / finding an id** → `plungeai-discovery`.
- **"Why did that run fail / how long / what did it cost"** → `plungeai-results-traces`.

## Discovery first (every door, non-negotiable)

Catalogs are live — the agent registry, tool contracts, model list, and workflow inventory
change without notice. Never assert what exists from memory:

- MCP: `plungeai_list_agents {search: "<capability>"}`
- One API: `GET /v1/discovery/search?q=<capability>`, `GET /v1/agents`, the live contract at
  `GET /v1/openapi.json`
- CLI: `ocean registry lookup <query>` / `ocean agent contract <id>`

## Verify you're in

- **MCP:** call `plungeai_whoami` — identity card (user id, tier, key label, rate window).
- **One API:** `curl -s https://api.plungeai.com/health` (no auth) proves the router is up;
  `curl -s https://api.plungeai.com/v1/agents -H "Authorization: Bearer ozk_YOUR_KEY"` proves
  the key.
- **CLI:** `ocean doctor` (exit 0 = ready).

## Related skills

- `plungeai-mcp-setup` — connect and operate the MCP server.
- `plungeai-api-setup` — auth, first call, OpenAPI, codegen for the One API.
- `plungeai-cli-setup` — install, auth, full command reference for `ocean`.
- `plungeai-in-<tool>` — per-editor connect steps (Cursor, VS Code, Claude Code, Codex, …).
- `plungeai-platform` — the full capability map (agents, tools, workflows, models, missions,
  scheduling, memory, skills/plugins, observability) once you're connected.