ProductOS

Create a new ProductOS project: registers it in the workspace, initializes its Git repository, applies the chosen template, and optionally provisions + boots its sandbox. Returns the project id, repo, and sandbox/preview URLs. IMPORTANT — pick `template` from what the user actually wants, don't just default to web: a MOBILE app / iOS / Android / React Native / Expo → 'mobile'; a marketing/landing/brand/blog/SEO site → 'website'; a web app / dashboard / SaaS → 'web-app'. If the user says 'app' without qualifying and the context is mobile, prefer 'mobile'; if genuinely unsure, ask them. Requires project:write scope and a non-viewer workspace role.

create_project

Create and steer a ProductOS Product (several platform projects — web / mobile / website — sharing one frozen spec, one database and one orchestrator agent). Actions: 'create' (from a brief + surfaces: provisions the shared database, creates one project per surface, and starts the ProductOS Agent in PLAN MODE — nothing builds until you approve its plan with product_agent); 'add_surface' (add a platform to an existing product and build it against the existing contract); 'sync_spec' (re-freeze the shared contract — this REBUILDS EVERY SURFACE, so confirm with the user); 'resume' (recover a stalled product: backfill missing platform projects, restart a dead orchestrator, re-dispatch dead builds). Every action spends credits. Use create_project instead when the user wants ONE standalone app. Requires project:write.

manage_product

Permanently delete a ProductOS project — its sandbox and volume are reaped, project storage is cleaned up, the cross-surface registry entry is tombstoned, and the project row is removed. This cannot be undone. Requires project:write scope and workspace permission to manage the project.

delete_project

Delete a file or directory from the project sandbox. Pass recursive:true to delete a non-empty directory. The project root cannot be deleted. Requires project:write scope.

delete_file

Deploy the active project to production: GitHub push → Vercel deployment (deterministic, no auto-fix). Works in both Manual and Automatic deployment mode — calling it is the user's explicit deploy. Runs asynchronously and shows live in the ProductOS UI. On a build failure it stops at FAILED with the build logs — read get_deploy_logs, fix the code (edit_file/bash), and call trigger_deploy again. Poll get_deploy_status for status/URL. Requires project:write scope.

trigger_deploy

Modify an existing file by replacing exact strings — the right tool for surgical code edits and refactors without rewriting the whole file. Edits apply in order; each oldString must appear exactly once unless replaceAll is set. Requires project:write scope.

edit_file

Estimate infrastructure costs for different deployment options. Compares serverless vs container vs VM strategies at multiple scale tiers. Use this when writing the Infrastructure & Deployment architecture section. The result is formatted as a markdown comparison table that you should include in the architecture section body.

estimate_infrastructure_cost

Fetch extracted text for a list of URLs you already have (from a prior `exa_search` or from the user). Each page is capped at 4000 characters to keep token usage sane.

exa_fetch

Find files by filename glob across the project sandbox (build artifacts pruned, capped at 500 results). Matches the file NAME, e.g. 'page.tsx', '*.config.*', 'tailwind.config.*'. To search file CONTENTS use search_files. Requires project:read scope.

find_files

Return the real failure logs for a mobile EAS build — the 'Run gradlew' (Android) / Xcode (iOS) phase output, plus the extracted cause. Use this whenever a Play Store / App Store build fails, ESPECIALLY when the status says "unknown error — see logs for the Run gradlew phase": that message is EAS's classifier giving up, and this tool fetches what it points at. Defaults to the project's most recent mobile build. Pass grep to filter (e.g. 'Execution failed|e: file://'). Requires project:read scope.

get_eas_build_logs

Returns a markdown summary of this ProductOS project: name, current stage, overview, PRD, research, design notes. Reads live wiki files from the project's sandbox — always the latest, no staleness. Call this first when the user wants you to work in their ProductOS project. v1 read-only.

get_project_context

Read the full body of one logged decision (PRD section, page) from this project's sandbox wiki. Pass an `id` from list_decisions (a wiki-relative path like 'agents/prd/sections/overview.md'). Returns markdown with title + stage + body. Live data — no DB lag.

get_decision

Return build AND runtime logs for a deployment. Build logs explain why a deploy failed to compile; runtime logs explain why a deployed route returns 500 (missing env var, Prisma init failure, DB unreachable). Falls back to fetching live from Vercel when nothing was captured at deploy time. Secrets and connection strings are redacted. Defaults to the latest deployment. Requires project:read scope.

get_deploy_logs

Orient in ProductOS Product mode — a Product groups several platform projects (web / mobile / website) that share ONE frozen spec, one database, and one orchestrator agent. Call this FIRST whenever the project you're working on might belong to a Product: it lists the sibling surfaces, whether the shared contract is frozen (and at which version), and what the ProductOS Agent is doing. With no arguments it resolves the Product owning the connection's active project, or — if that project is standalone — lists every Product this connection can reach. Follow up with read_shared_context (the contract each surface must satisfy) and product_agent (the main agent). Requires project:read.

get_product_context

Query a project's configuration in one call: name, stage, project type + framework template, GitHub repo/branch, workspace, database/storage state, and sandbox identity. Database metadata refreshes on every call and recognizes existing DATABASE_URL settings, shared product databases, secrets, and running sandbox configuration; it does not test connection health. Requires project:read scope.

get_project_metadata

Returns a dated summary of recent project activity from canonical wiki memory and sub-agent outputs. Use it on demand when the request depends on earlier work; it is not a prerequisite for starting a turn.

get_recent_activity

Return the live preview URL for a project's running sandbox (and the Expo tunnel URL for mobile projects). Use to view or share the running app. If the sandbox isn't running, start it first with start_sandbox / open_project. Requires project:read scope.

get_sandbox_urls

Tail the dev-server log for a project's sandbox — use to debug build errors, runtime crashes, or a preview that won't load. Returns the last N lines (default 200) of the type-aware log file. Requires project:read scope.

get_sandbox_logs

Report a project's sandbox health: instance status (DEPLOYED/…), whether the dev server is responding, whether it's currently compiling, last-active time, and the sandbox id. Requires project:read scope.

get_sandbox_status

Git operations on the project sandbox. action='status' shows the working tree + recent commits (project:read). action='commit-push' commits the live sandbox state and pushes it to the project's GitHub repo via the durable commit pipeline — file writes via MCP already auto-commit, so use this to force an immediate sync point (project:write). action='pull' pulls the latest from the project's GitHub repo INTO the sandbox — it first backs up the current tree to S3 so the pull is undoable, and refuses while an agent turn is mid-write (project:write).

git_sync

Import an existing GitHub repository (an existing codebase) as a new ProductOS project: downloads the code into a live sandbox, detects the stack (Next.js, Vite, Astro, Expo, Node, Python, PHP, Go, static — anything else runs on a universal image), starts installing dependencies and the dev server, and returns the project id + preview URL. The project stays linked to the repository. Use this — not create_project — when the user wants to work on code they already have on GitHub; add_context_repo only attaches a repo as reference docs to an existing project. The user's GitHub account must be connected to ProductOS; list_available_repos shows the repositories it can read. Importing the same repository and branch again returns the existing project instead of a duplicate. Takes a few minutes on a cold start. Requires project:write scope and a non-viewer workspace role.

import_github_repo

Link a GitHub repository to this project so agents can understand the codebase. A Code Wiki (structured architecture docs) will be generated automatically. This does NOT bring the code into the project — to import a repository as a new, runnable project, use import_github_repo. IMPORTANT: Always ask the user for confirmation before linking a repository.

add_context_repo

List the design / PRD / research decisions logged in this ProductOS project, read straight from the live sandbox wiki (no DB lag). Returns a JSON array with id (wiki-relative path), title, type, position, updatedAt for each. v1 returns PRD section files and pages; structured alternatives / rationale fields ship in v1.1.

list_decisions

List files and subdirectories in one directory of the project sandbox (non-recursive). Build artifacts (node_modules, .git, .next, dist, build) are hidden. For a full recursive tree use read_project_structure. Requires project:read scope.

list_files

List the ProductOS projects this MCP connection can access, with each project's access level (READ / WRITE / FULL_DEV), current stage, and id. Projects that are platforms of a multi-platform Product are grouped under it — use get_product_context for that Product's shared spec and orchestrator agent. The active project is marked — switch it with open_project, or pass projectId to any file/sandbox tool to target another project directly.

list_projects

List the user's GitHub repositories that can be imported as a project (import_github_repo) or linked for codebase context (add_context_repo). Returns name, full_name, description, default_branch, and language for each repo. Use this to suggest which repos to link when the user describes an existing product.

list_available_repos

List the reusable agent skills (playbooks) available to this connection — platform skills shipped by ProductOS plus any this workspace or project defines. Each entry is a slug + description; call get_skill with a slug to read the full instructions. CHECK THIS FIRST when a task sounds like a repeatable workflow (cloning a website, an SEO pass, a design-system import) — following an existing skill beats improvising.

list_skills

List the ProductOS organizations (workspaces) this MCP connection can access, with your role in each. Use list_projects to see the projects inside them. Requires project:read scope.

list_organizations

Manage tabs in the shared browser session: list them, open a new one, switch by id/label (t1, t2, …), or close one. Requires project:exec scope.

browser_tabs

Load all active project constraints (legacy APIs, compliance requirements, tech debt, security, performance, infrastructure). ALWAYS call this before writing PRD sections, architecture docs, or making technical decisions. Constraints are structured inputs from the project owner that MUST influence your output.

load_constraints

Record ideation assumptions. Pass every new assumption in ONE `assumptions` array so the file is read and written once. The legacy singular shape remains supported.

log_assumption

Record open ideation questions. Pass every new question in ONE `questions` array so the file is read and written once. The legacy singular `question` + `why` shape remains supported.

log_open_question

Log 1-30 QA findings in a single call. ALWAYS batch — do not call this once per finding. Each finding needs severity, type, title, and (recommended) evidence with the route + screenshot URL.

qa_log_finding

Record ALL worthwhile source URLs for this turn in a single call. Pass every source as an entry in the `entries` array — do NOT call this tool per URL.

log_source

Record ALL competitors discovered this turn in a single call. Pass every competitor as an entry in the `competitors` array — do NOT call this tool per competitor.

log_competitor

Record ALL validated research findings for this turn in a single call. Pass every finding as an entry in the `findings` array — do NOT call this tool multiple times in the same turn.

log_finding

List, set, or delete a project's environment variables (the Secret Manager backing the sandbox's .env). 'list' returns key names only — values are encrypted and never exposed. 'set'/'delete' also sync the sandbox .env so the running app picks the change up. DATABASE_URL is reserved (use provision_database). Requires project:write scope.

manage_env_vars

Add, remove, or install npm dependencies in the project sandbox. 'add' installs the given packages, 'remove' uninstalls them, 'install' installs everything in package.json. Package names are validated. Requires project:exec scope.

manage_dependencies

Rename or move a file or directory within the project sandbox. Parent directories of the destination are created automatically. Requires project:write scope.

move_file

Navigate the project sandbox's Chromium to a URL. The app being built is at http://localhost:3000 — reachable ONLY from inside the sandbox, which is why this tool exists rather than fetching the URL yourself. Follow with browser_snapshot to see what is on the page. Shares one browser session with the in-app agents and the user's live Browser panel. Requires project:exec scope.

browser_navigate