ProductOS
MCP116 tools, one connection URL

ProductOS MCP server

Your whole product,inside Claude Code.

Connect Claude, Cursor, Codex, or Windsurf to ProductOS. They get your live PRD, research, and designs, plus a cloud sandbox, a real browser, databases, and one-call deploys. No local clone, and every change lands in your GitHub.

Connect your clientSee setup in 60 seconds

OAuth sign-in · Every plan · Per-project permissions

Claude Code · Terminal
claude mcp add --transport http productos https://beta.productos.dev/api/mcp/<your-id>

Replace <your-id> with your connection ID from ProductOS → MCP Access.

Claude Code · ProductOS · illustrative session

Checkout breaks on mobile Safari. Fix it and ship.

  1. productos ›get_project_context
  2. productos ›search_files("checkout" in app/)
  3. productos ›edit_file(app/checkout/page.tsx)
  4. productos ›browser_navigate(localhost:3000/checkout)
  5. productos ›browser_debug(console)
  6. productos ›trigger_deploy
116
MCP tools
5
Clients with guided setup
3
Access levels per project
0
Credits to read, check, or deploy
What your client gets

Not just context.
The whole machine.

Most MCP servers hand your assistant something to read. ProductOS hands it the product: the thinking behind it and the environment it runs in, over one connection.

Layer 01 · Live context

It knows the product

No more pasting the spec into every chat. Your client reads the current project, and writes its work back where the rest of the pipeline can use it.

The PRD

Scope, user stories, and acceptance criteria, read live every time.

The research

Findings, competitors, and sources behind every product call.

The design

Flows, brand guidelines, and the DESIGN.md your UI answers to.

The memory

Decisions, notes, uploads, and transcripts, semantically searchable.

Layer 02 · Full control

It can build the product

The project's own cloud environment, drivable from any device. Edit, run, test in a real browser, provision a backend, and ship, all without a local checkout.

  • Cloud sandbox + shell
  • Headless Chromium
  • Postgres + storage
  • GitHub, auto-committed
  • Vercel deploys, verified
  • App Store + Play

# the sandbox is remote, your editor is anywhere

productos › bash("npm run build")

✓ Compiled · 0 type errors · auto-committed

Use cases

Ask in plain English.
Watch the whole job happen.

Each of these is one request in your client, carried out as a chain of real ProductOS tool calls.

Ship a fix

From bug report to production, in one chat

Your client reads the spec, finds the code, fixes it on the remote sandbox, checks it in a real browser, and ships. Nothing is cloned to your laptop.

6 tool calls · 1 request

Checkout breaks on mobile Safari. Fix it and ship.

  1. 1

    get_project_context

    ✓ PRD, checkout flow, and 3 related decisions loaded

  2. 2

    search_files"checkout" in app/

    ✓ 4 matches · app/checkout/page.tsx:88

  3. 3

    edit_fileapp/checkout/page.tsx

    ✓ 1 edit applied · auto-committed to GitHub

  4. 4

    browser_navigatelocalhost:3000/checkout

    ✓ Loaded in the sandbox's Chromium

  5. 5

    browser_debugconsole

    ✓ 0 errors · 0 failed requests

  6. 6

    trigger_deploy

    ✓ GitHub push → Vercel · READY · verified

Try it yourself

Start with a sentence.
Leave with something shipped.

Connect your project, copy a prompt into your AI client, and make it your own. Open a card to see how ProductOS helps.

01 / Ship a fix

“Checkout breaks on mobile Safari. Fix it and ship.”

What ProductOS does

Your client reads the spec, finds the code, fixes it on the remote sandbox, checks it in a real browser, and ships. Nothing is cloned to your laptop.

  1. 1.PRD, checkout flow, and 3 related decisions loaded
  2. 2.4 matches · app/checkout/page.tsx:88
  3. 3.1 edit applied · auto-committed to GitHub
  4. 4.Loaded in the sandbox's Chromium
  5. 5.0 errors · 0 failed requests
  6. 6.GitHub push → Vercel · READY · verified

Illustrative workflow. Results depend on your project and connection permissions.

02 / Start a product

“Build a booking product for yoga studios: web app, iOS app, marketing site.”

What ProductOS does

Create a Product from a paragraph. The ProductOS Agent plans it, freezes one shared spec and database, and builds every surface in parallel while you approve from your client.

  1. 1.Shared database provisioned · agent in plan mode
  2. 2.Plan ready: 14 screens, 9 tables, 3 surfaces
  3. 3.Contract frozen · 3 surface builds dispatched
  4. 4.The schema every surface builds against
  5. 5.Expo tunnel + QR code ready to scan

Illustrative workflow. Results depend on your project and connection permissions.

03 / Add a backend

“Give the app accounts and file uploads.”

What ProductOS does

Provision Postgres with Prisma already wired, give the app its own file storage, and set API keys without their values ever being echoed back.

  1. 1.Neon Postgres · DATABASE_URL + Prisma configured
  2. 2.Isolated storage · credentials written to .env
  3. 3.Saved encrypted · sandbox env synced
  4. 4.Schema in sync · 6 tables
  5. 5.All routes 200 · database reachable

Illustrative workflow. Results depend on your project and connection permissions.

04 / Publish an app

“Put the iOS app on TestFlight.”

What ProductOS does

Set the app identity, kick off the EAS build, and submit to the stores. When a build fails you get the real gradlew or Xcode output, not a spinner.

  1. 1.Apple connected · identity not set
  2. 2.com.studio.booking · “Studio”
  3. 3.EAS build queued → TestFlight
  4. 4.Xcode phase passed · submitted

Illustrative workflow. Results depend on your project and connection permissions.

05 / Research & spec

“Research the market for AI bookkeeping, then draft the PRD.”

What ProductOS does

Delegate research or the PRD to the same agents that run inside ProductOS. They write their results back into the project, where every other stage can use them.

  1. 1.Cited brief · 11 competitors · 38 sources
  2. 2.6 matches from interviews and uploads
  3. 3.PRD drafted section by section
  4. 4.Updated · visible in the in-app PRD view
  5. 5.Saved to project memory

Illustrative workflow. Results depend on your project and connection permissions.

Your MCP client

manage_product("create")

ProductOS Agent

Plans, freezes one shared spec, dispatches builds

Web app

Next.js

Mobile

Expo

Website

Astro

one database · one spec/prd.md · one design-tokens.json
Product mode

One brief.
Every surface.

From your client, create a Product that fans out into a web app, a native mobile app, and a marketing site. The ProductOS Agent plans it, freezes one shared contract, provisions one database, and builds every surface against it. You approve the plan, answer its questions, and steer, all over MCP, in the same session the Product page shows live.

manage_productproduct_agentget_product_contextread_shared_context
Skills, prompts & resources

Your playbooks,
in every client.

Skills are the step-by-step methods ProductOS's own agents run on, plus the ones your team writes. Over MCP they arrive three ways, so an external agent follows the same playbook the in-app agents do.

  • As tools. list_skills and get_skill return the full SKILL.md to follow.

  • As slash commands. /clone-website in Claude Code, /mcp-productos-clone-website in Cursor.

  • As resources. Attach skill://<slug> from any client with an @-mention picker.

  • Written back. create_skill saves a new procedure for the whole workspace.

Claude Code

› /start-product-work checkout redesign

Orient → build → verify in the live preview → sync to GitHub.

Built-in skills

/web-development/code-review/seo-optimization/analytics/aws-deployment/quality-standards/clone-website/browser-automation+ your workspace skills

productos › create_skill("release-checklist")

✓ Saved to workspace · available to every teammate's agent

Permissions & security

Powerful by design.
Scoped by default.

You decide exactly what each connection can reach and how far it can go. The default grant is read-only.

project:read

Level 01

Read-only

Read project files, wiki, PRD, and semantic memory. Check sandboxes, deploys, and logs.

Good for: Planning and review in Claude or ChatGPT.

project:write

Level 02

Read & Write

Create, edit, move, and delete files. Write the PRD and wiki, provision a backend, deploy.

Good for: Shipping features from Cursor or Claude Code.

project:exec

Level 03

Full development

Run commands, manage dependencies, control sandboxes, and drive the headless browser.

Good for: Autonomous agents doing the whole loop.

OAuth 2.1, no token to copy

Paste one URL and sign in through your browser. Dynamic client registration and refresh tokens keep the connection alive. Prefer a key? pos_live_ tokens expire on your schedule.

One project, a few, or a workspace

Grant a single project, a hand-picked set with a level for each, or a whole workspace, optionally including projects created later.

Never more than your role

A connection can never exceed your own workspace permissions, and membership is re-checked on every call. Lose access and the next write is refused.

Every call on the record

See what each connected app and API key did: activity, credits used, and the full tool-call log. Revoke any app or key in one click.

Setup

Connected in a minute.
Signed in, not configured.

Copy your connection URL from ProductOS, add it to your client, and approve the browser sign-in. Pick the projects and the access level on the consent screen.

Claude Code

  1. 1

    Copy your connection URL from ProductOS → MCP Access.

  2. 2

    Run the command below in any terminal.

  3. 3

    Run /mcp in Claude Code, sign in, and pick your projects.

Get your connection URL
Terminal
claude mcp add --transport http productos https://beta.productos.dev/api/mcp/<your-id>

Replace <your-id> with a project or workspace id. ProductOS → MCP Access gives you the exact URL, plus one-click buttons for Cursor, Claude Code, Codex, and Claude Desktop.

Fair metering

Pay for work.
Not for calls.

The MCP server works on every plan, including Free. Reading, checking, and deploying cost nothing. You only spend credits when real compute or AI runs, at exactly the prices the web app charges. MCP is never stricter than the web.

Start on FreeCompare plans

What a call costs

get_usage · free
  • Reading context, listing, status, logs0 credits
  • File reads and edits0 credits per call
  • Deploying to production0 credits
  • Shell, browser, and sandbox timeSandbox runtime
  • Agent runs (delegate_to_*, product_agent)Actual tokens used
  • Palette, font pairing, vibe report1 credit each
Why a protocol

Pasted docs are a snapshot.
MCP hands over the keys.

Pasted docs
ProductOS MCP

Always the current PRD, research, and designs

Writes decisions and specs back to the project

Edits and runs code on a real cloud sandbox

Tests the app in a real browser

Provisions a database and storage

Deploys to production and reads the logs

Publishes to the App Store and Google Play

Permissions per project, revocable any time

FAQ

Frequently asked questions

  • It is a remote Model Context Protocol server that exposes your ProductOS projects to any MCP client. A connected client gets your live PRD, research, design notes, and memory, plus the project's cloud sandbox: files, a shell, a real browser, databases, storage, GitHub sync, deploys, and mobile publishing. That is 116 tools in total.

  • ProductOS ships guided setup for Claude Code, Cursor, Codex, Claude Desktop, and Windsurf, including a one-click Add to Cursor button. Any other client that speaks MCP over Streamable HTTP can connect with the same URL, using OAuth sign-in or an API token.

  • No. Every file, shell, and browser tool runs on the project's remote cloud sandbox, so you can drive a project from any machine, including one with nothing installed. Every change is auto-committed to the project's GitHub repository.

  • Paste the connection URL and sign in with OAuth 2.1 in your browser, or use a pos_live_ API token for clients that prefer one. On the consent screen you choose one project, several projects, or a whole workspace, and an access level for each: Read-only, Read & Write, or Full development. A connection can never exceed your own workspace role, and access is re-checked on every call.

  • Every plan, including Free. Connecting is not gated by plan. Listing projects, checking deploys, and deploying cost no credits (the Free plan allows 5 deploys a day). Agent runs, sandbox time, and AI generation use credits at the same prices as the web app. Store submission through mobile_publish needs a paid plan.

  • Yes. The MCP usage page in ProductOS shows what each connected app and API key did with your account: activity per app, the credits it used, and the tool-call log. You can revoke an authorized app or key at any time.

  • Skills are reusable playbooks, such as cloning a website or running an SEO pass. Your client can list and read them as tools, run them as slash commands (for example /clone-website in Claude Code), or attach them as skill:// resources. When an agent works out a procedure worth keeping, create_skill saves it for the whole workspace.

  • A pasted PRD is a stale copy the moment you paste it, and it cannot do anything. Over MCP the client reads the current project every time, writes its work back where the rest of the pipeline can use it, and can act on the product: edit code, test it, and ship it.

Your assistant already thinks.
Now let it ship.

One URL connects your favorite AI client to 116 ProductOS tools: 60 for your project and sandbox, 56 from the specialist agents.

Connect your clientRead the MCP docs

Works on every plan · OAuth sign-in · Revoke any time