MCP App Store
by KeenEthics
ParallelSandbox icon

ParallelSandbox MCP Server for ChatGPT

By Runvo LLC

Overview

Connect your ParallelSandbox account to build, run and test projects on isolated remote computers. Execute commands, inspect screenshots and logs, download artifacts, and share a working preview. Sign in with OAuth. Remote connections cannot directly access files on your computer.

How to connect

  1. ChatGPT: Open the ParallelSandbox listing in the ChatGPT app directory and choose Connect. ChatGPT listing ParallelSandbox exposes 29 tools here.

Tools

logs_errors

ChatGPT
List error-level client logs with stacks resolved through uploaded source maps.

logs_tail

ChatGPT
Long-poll for new client logs; returns when rows arrive or waitSec elapses. Pass the cursor back to continue.

sandbox_architecture

ChatGPT
Draw how the parts fit together before building: a box per app, service, database, queue or outside API and an arrow for who calls whom, laid out top to bottom automatically as a plain, clean diagram (straight arrows, simple boxes; new: true in blue). Use it when the work adds or changes services, or the person asks for an architecture or flow diagram (架構圖). Name nodes after the box's services so the person can match them. Designs belong to the box of this piece of work: pass its id (sandbox_start one first if you have none; drawing never wakes it, so it can stay frozen while you design, and the same box card in the person's app then goes from draft to review). The picture comes back in this result for this conversation, and the person sees the same version in their app on the box's page, where they can circle, talk and write on it. That feedback returns here like review feedback (fromHuman, or sandbox_report): there is no approval step, so change what they asked and call this tool again with the same topic and a note saying what changed; that becomes the next version (v2, v3…). Write every label in the language the person reads. Do not make HTML or image files for this instead. Order of work for anything new or changed: sandbox_draft (screens) → sandbox_architecture (services) → sandbox_schema (stored data) → build in the box → sandbox_review. Skip a step only when the task does not touch it.

sandbox_build

ChatGPT
Run a build step and reuse its output: the same inputs (dir contents, cmd, env, toolchain versions) restore the previous result instead of compiling again. Prefer it over sandbox_exec for npm ci, go build or next build, e.g. {dir: "app", cmd: "npm ci", out: ["node_modules"]}; reused=true means nothing compiled, cached=true means this run's output was saved for later boxes. For an install step alone (npm ci, pnpm install, yarn) whose out is only node_modules, the version field of the package.json and package-lock.json at the top of dir is left out of the fingerprint, so a version bump still reuses it.

sandbox_design_final

ChatGPT
Mark a design final, or undo that. A design that is not final stays under Ready for you in the person's app until they report on its latest version (the next version you draw puts it back); a final one leaves it and stays reachable by its link and on its box's page. Call it with the designId as soon as the person agrees with the design. Going on to the next step does it by itself: drawing a later kind (the architecture or the schema after the draft, the schema after the architecture) marks the earlier ones final, and sandbox_review marks all of them final and shows them on that box's page, in this conversation or on the same box. The person can also do this with one tap on the design's page. Drawing a new version (the same topic again) puts the design back to not final by itself, so call this again once that version is agreed.

sandbox_device

ChatGPT
Lease a phone for the box, on separate hardware: an Android emulator, or an iPhone simulator on a Mac. attach blocks until it boots. It freezes with the box (an Android emulator keeps its memory; an iPhone simulator is shut down and restarts its apps) and is attached again when the box thaws. list does not wake the box: it shows frozen devices, failed ones with the reason, and whether each platform's device host is online with free slots, its OS versions and the phones' outgoing IP (not the box's), so check it before building for a phone. The box's screen then IS the phone's screen: sandbox_shot, recordings and takeover all show it. Android also appears to adb in the box as a local device (drive the app with artemis-adb) and takes taps and typing during takeover; psbx-webview <package> forwards an app's WebView DevTools. When adb drops, the box reconnects it by itself, and a crashed or hung emulator restarts on its host with the same serial, apps and data (list shows offline or restarting meanwhile; reconnect retries now). restart reboots a phone in place, keeping apps and data; an iPhone restart also applies simctl ui settings and clears stuck system dialogs. iOS has no adb: the box gets psbx-ios (plus simctl and xcodebuild wrappers) that forward to the Mac (psbx-ios help lists what it does). Every psbx-ios verb runs in the Mac's copy of /work: psbx-ios sync /work/app puts it at work/app there, give paths relative to /work, and build products stay on the Mac. printf '你好' | psbx-ios type types any text, Chinese and emoji included, and a person on the box's screen taps and types on the simulator too. Building a Capacitor or React Native iOS project there means psbx-ios sync of the ios/ folder AND the node_modules the Xcode project links to, at the same relative path, or the package graph will not resolve. The Mac runs iOS simulators only: no macOS desktop apps, no signing for App Store builds.

sandbox_draft

ChatGPT
Sketch screens before building them: hand-drawn phone mockups, up to 3 boards of up to 4 phones, each phone a list of items, with red and gray notes under it. Use it whenever the person asks for a draft, sketch or wireframe (草稿), and before you build a new or changed screen, so they can judge the layout and flow on their phone first; in the app they can also step through the phones one at a time. Draw only what they need to judge: new: true marks what is new or different compared with the product as it is now (drawn red), the rest stays gray; scribble unimportant text (type scribble) and set unchanged: true on screens that stay as they are. What changed since the previous version goes in note. Look at the existing screens before sketching changes to them. Designs belong to the box of this piece of work: pass its id (sandbox_start one first if you have none; drawing never wakes it, so it can stay frozen while you design, and the same box card in the person's app then goes from draft to review). The picture comes back in this result for this conversation, and the person sees the same version in their app on the box's page, where they can circle, talk and write on it. That feedback returns here like review feedback (fromHuman, or sandbox_report): there is no approval step, so change what they asked and call this tool again with the same topic and a note saying what changed; that becomes the next version (v2, v3…). Write every label in the language the person reads. Do not make HTML or image files for this instead. Order of work for anything new or changed: sandbox_draft (screens) → sandbox_architecture (services) → sandbox_schema (stored data) → build in the box → sandbox_review. Skip a step only when the task does not touch it.

sandbox_environments

ChatGPT
List your environments (your own dev or staging). No tool creates or changes them: do that over REST with your token (POST /v1/environments, POST /v1/environments/{env}/connections, PUT /v1/environments/{env}/connections/{id}/endpoints, PUT /v1/environments/{env}/services/{name} with a .env body; https://parallelsandbox.com/en/docs/environments/#set-it-up-over-rest). For each: the private host:port a box can reach through your connector and whether the connector is online (connectorOnline means at least one; connections[] shows each network's connector on its own, with rttMs, the round trip to it, and the addresses that go through it), the services whose settings a box gets as env files (keys, and notable: the connection, mode and permission settings to check first; deployedImage when imported from AWS ECS), activeBoxes (your live boxes started with it), and externalBaseUrl. Pass the name to sandbox_start as environment to run only the services you changed in the box against the rest of that environment. For tests, do not point them at the environment's database: run psbx-testdb up in the box for a clean Postgres of your own. An environment address may also be a public host: a box reaching it goes out through your connector, from your own network, which is how to check whether your services can reach an external site — a box's own egress is not theirs.

sandbox_exec

ChatGPT
This remote connection cannot read or upload files from the person's computer. A local path such as /Users/me/project is not accessible from a box. Do not start a box or run commands merely to probe that laptop path; ask for an accessible repository or an authorized transfer first. Run a bash command on the box. Foreground returns stdout, stderr (the last 16 KB of each; when truncated, outputUrl has it all), exitCode and an execId; background returns a bgId and a log path. pkill -f and pgrep -f match any other job whose command line holds the pattern: stop background jobs by bgId with sandbox_procs. Secret and setting values come back as ****. A foreground command's screen changes are recorded, with a screenshot at the end, and shown to the person beside that step (the recording for 7 days, the screenshot for 30): run browser and app tests headed on the display (DISPLAY=:99 is set) so each step shows what was tested. Commands run as root, so Chromium and Electron need --no-sandbox; tests of programs that switch uid need user: "tester". Output is not a TTY, so test runners print CI formats (node --test prints TAP). The clock is UTC and browsers default to en-US: start Chromium with TZ=<zone> and --accept-lang=<lang> (Playwright: timezoneId, locale). A Chromium window is at least 500 px wide; on the portrait screen (390x844) use --force-device-scale-factor=0.78 --window-size=500,1082 --window-position=0,0 to fill it (only for you, never to hand over). For a page narrower than that, add --remote-debugging-port=9222 and call sandbox_shot target tab with width: the box keeps that viewport. Containers resolve names through the box's DNS at 172.17.0.1: give that to nginx's resolver (127.0.0.11 exists only on user-defined networks). With an environment's AWS role, docker run -e AWS_CONTAINER_CREDENTIALS_FULL_URI -e AWS_REGION gives containers its credentials. The browsers match Playwright 1.56.0: for another version run npx playwright install chromium first. A test starting its own ibus-daemon needs env -u IBUS_ADDRESS.

sandbox_feedback

ChatGPT
Send an optional, task-specific product feedback report to the ParallelSandbox team. Use only when the person has authorized sending it and the client policy permits it. Say what ran, which tools were used, any relevant errors and suggested improvements. Do not include secrets, unrelated personal data, or conversation transcripts. Sending feedback is not required to operate, stop, or hand over a box.

sandbox_get

ChatGPT
Download files or directories from the box: under /work, /tmp or /dev/shm. Returns a download URL valid for one hour (expiresAt; on ParallelSandbox's API, with no storage credentials in it; call again for a fresh one if a download is refused), and for an image small enough to show, the picture itself, so you do not have to fetch the URL to look at it. Directories come back as tar.gz, with the directory itself as the top entry. Pass paths instead of path to fetch several in one call; the first 10 images, up to 8 MB in all, are shown too, and the rest come as URLs only. What you fetch is handed over, not stored: the file is kept only about a day, so save anything you want to keep yourself.

sandbox_list

ChatGPT
List the boxes in this account, most recently used first (at most 100): id, name, goal, status, agent (whether the conversation that last used it is still at it: state working, away, left or idle; thisConversation when that is you; untracked when it was last used without a conversation id, by an API-key script or REST), placement, size, sceneUrl, webUrl, services (each web service's url; a link shows its fromBox), linkedFrom (live boxes linked to this one), recentNotes (the notes of its last 3 steps, oldest first: what it is doing and with which test accounts or resources, without a sandbox_status per box), stopsAt (when the idle rules stop it for good unless it is used before then) and restorableUntil (a stopped box sandbox_start with restore can still bring back). Every API key of the account sees the same list, so it includes boxes your teammates started. Use it to find the id of a box to link to with services[].fromBox, or to pick a box back up. Only live boxes by default; all: true adds stopped ones. Read-only: listing never wakes a frozen box or counts as using it. Stop boxes nobody needs any more: a running box uses credits.

sandbox_media

ChatGPT
List the screenshots and recordings that steps left in every box of this account, stopped boxes included, oldest first. No box id is needed, and it is not limited to the 100 boxes sandbox_list shows. Each step gives at, boxId, the box's boxName and goal, the step's kind (exec, shot and so on), summary and note, and media[]: kind image or video, bytes, and a download url valid for one hour. Screenshots are kept 30 days. Recordings are kept 7 days: after that a step keeps only its screenshot, and a step that had only a recording is gone. Use it to gather what was built and checked over a period, such as last week's changes for a release note: since and until pick the period, query narrows it to a box or a feature. A page holds limit steps (default 20, at most 50); pass nextCursor back as cursor, with the same since, until and query, for the next page. Read-only: it never wakes or uses a box.

sandbox_procs

ChatGPT
List, wait for, or stop the background commands on a box (sandbox_exec with background); a foreground command's execId works as a bgId too, so a result lost with a dropped connection can still be fetched or waited for. Job operations are scoped to the returned bgId. stop ends the whole process group, including descendant processes. Use it instead of pkill -f or pgrep -f, which match every process whose command line contains the pattern, other jobs included. wait with until "ready" returns once a server is up (readyPort or readyLog). list shows each job's cpu and whether this conversation started it (mine), and the foreground commands running now: on a box several conversations share, that is who is using the CPU. Commands survive a restart of the box's agent (boxd); one that ended meanwhile has exitCode -1 and an endReason. Calls count as use of the box.

sandbox_publish_version

ChatGPT
Record an image you pushed to your tenant registry as a named version of a service so other boxes can run it: start another box with services[].version to run it under a name.

sandbox_report

ChatGPT
Read an account-owned human report by its stable reportId, including notes, annotated images, recording files and timed transcripts. It can be read again after an earlier tool returned it, and does not claim the box or consume other pending messages. File URLs are refreshed when read. A recording made in a browser shows replayVideo "pending" while its screen video is still being made from the page replay: read the report again a few minutes later to get video ("failed" means voice, screenshots and actions only). The receipt only records preparation for a tool handoff, not that the AI understood or finished the work. Reports and their media remain available for 7 days.

sandbox_review

ChatGPT
Hand a version you have tested to the person to try as a user. Give them the returned shareUrl, the review page with the feedback tools: no ParallelSandbox sign-in is needed while the review waits, and colleagues can use the same link; productUrl is the product itself. Their app immediately shows the review card; progress includes shareUrl while this call waits for their report or completion, within the caller's budget (25 seconds unless configured, up to 30 minutes; see waitSec). The report returns as fromHuman with annotated images, recording links and timed transcripts so you can continue in this conversation. A timeout or cancellation keeps the review and feedback available: resume with reviewId, or replay a known reportId with sandbox_report. This active tool call does not wake a conversation that has already stopped. After this call returns, the person can paste the app's copy message for AI into this chat to continue with later feedback. Use waitSec:0 only to explicitly hand off without waiting. Test the flow first, fix what fails, and leave the product at its starting screen. open is a hard rule: anything in a browser, phone-size or behind sign-in too, goes as open web with port, its front end's port here, for their own browser on their own device; run it on the tested backend, open that URL, sign in there (dev auto-login, or a test account in what), check the start screen. For web, serve a production build, never a dev server (see port). open box only for a native app on DISPLAY=:99 or a sandbox_device phone. If web is possible, box is strictly forbidden, convenience is no excuse. The app's Watch AI entry shows the AI's exact session; use sandbox_takeover when the person needs to operate that session. A new what replaces the previous card; reviewId only resumes that exact round. A waiting review keeps neither the box nor its phone: the idle rules freeze and stop them as usual. When the person opens the review later, a frozen box wakes; a stopped one shows them the review has ended.

sandbox_say

ChatGPT
Tell the person watching this box in the app what you are doing or what you are stuck on. Commands alone rarely explain intent: post a line when you start something long or when you change plan. It is a status line, not a way to ask: when you need the person to decide something, ask them in this conversation, the way your client asks. Notes they leave for you in the app come back as fromHuman in your next tool call on this box, while this conversation holds it.

sandbox_scene

ChatGPT
Act inside the page the person has open at any of the box's URLs (sceneUrl or a web service's url): runs JavaScript there and returns the result. That page renders on their own phone or laptop, so it is not on the box's virtual display and sandbox_shot/takeover input cannot reach it — this can. Use it to drive the feature while they watch, or to read what they are looking at. Fails with a clear message when nobody has any of those pages open.

sandbox_schema

ChatGPT
Lay out the stored data before building, as text (not a picture): tables with their fields, each field with its type, a short note on what it holds (required on every field) and the table it references, if any. Use it when the work adds or changes what is stored, or the person asks for the schema. List only what this work needs; new: true marks tables and fields that are new or different compared with what is stored now; what changed since the previous version goes in note. Designs belong to the box of this piece of work: pass its id (sandbox_start one first if you have none; drawing never wakes it, so it can stay frozen while you design, and the same box card in the person's app then goes from draft to review). The schema comes back as text in this result (not a picture), and the person sees the same version listed as text in their app on the box's page, where they can circle, talk and write on it. That feedback returns here like review feedback (fromHuman, or sandbox_report): there is no approval step, so change what they asked and call this tool again with the same topic and a note saying what changed; that becomes the next version (v2, v3…). Write every label in the language the person reads. Do not make HTML or image files for this instead. Order of work for anything new or changed: sandbox_draft (screens) → sandbox_architecture (services) → sandbox_schema (stored data) → build in the box → sandbox_review. Skip a step only when the task does not touch it.

sandbox_secrets

ChatGPT
List your secret names. Values are never returned; they are injected into boxes that list them in sandbox_start. Pass id and names to inject them into a box that is already running, instead of syncing the key in as a file that then sits in /work.

sandbox_shot

ChatGPT
Screenshot the virtual display, its front window, a URL, or a tab already open in a browser on the box (returned inline and as a download URL valid for one hour), or start/stop an mp4 recording of the display. capturedAt in the result is when the picture was taken; path is a copy on the box (under /work/.sbx/shots) to sandbox_pull. With target url or tab, pageErrors lists what the page itself reported: console errors, uncaught exceptions and failed requests (an unresolved host, a 404), so a page stuck loading shows why. While a person is on the box's screen, the result carries takeover: true. To check a page you are signed in to at phone size yourself, start Chromium with --remote-debugging-port=9222 and use target tab with width, height and mobile: the box holds that viewport until reset. That is for your own checks: to show the page to the person, hand it over with sandbox_review open web, never the box screen. Always include a clickable Screenshot link to the exact returned url in the final response, even when embedding the image: chat clients may not render the inline or remote image. Each screenshot is also kept for the person in their app, with the box's other steps, for 30 days, and each recording for 7 days; sandbox_media lists them across all of the account's boxes.

sandbox_start

ChatGPT
This remote connection cannot read or upload files from the person's computer. A local path such as /Users/me/project is not accessible from a box. Do not start a box or run commands merely to probe that laptop path; ask for an accessible repository or an authorized transfer first. Start a box: a remote x86_64 (amd64) Linux machine with Docker, Node, Go, Python, Chromium, psql, redis-cli, mysql and a virtual display (arm64 images: exec format error). sceneUrl opens the box's first service and each web service gets its own url in services[]; anyone with one of these URLs can open it: use them exactly as returned and share them only with people who should see the box. An idle box is frozen after 20 minutes without a call, with /work kept; the next call thaws it. A frozen box is stopped for good 24 hours after its last use. idleTimeoutMin sets your own limit: the box stops for good after that many minutes without a call, frozen or not (at most 10080, 7 days). sandbox_status and sandbox_list give stopsAt; a frozen box stopped so is kept 24 hours more for sandbox_start with restore. An attached phone freezes and thaws with its box (an iPhone restarts its apps); while frozen it holds no device slot and is not billed. A sandbox_review waiting for the person keeps neither the box nor its phone: they freeze and stop as usual, and opening the review later wakes a frozen box. Commands started with background: true (a dev server, a long build) count as activity for up to 1 hour after your last call; after that a box freezes anyway (they carry on when the next call thaws it). Requests through the box's URLs count as activity for up to 2 hours after the last call; after that the box freezes, and the next page load in a browser wakes it again. Background fetches from an open tab don't wake it. With no room on any host it fails with "no box capacity right now" (HTTP 503 over REST); waitForCapacitySec waits for room instead. Guide for every sandbox_* tool: https://parallelsandbox.com/skill/SKILL.md

sandbox_status

ChatGPT
Status of a box: lifecycle state, boxd health, wiring table, sceneUrl, webUrl and each web service's url, takeoverUrl, and the reason if it was interrupted. links[] are this box's links to other boxes (their status, open and failed connections, last error); linkedFrom[] are the boxes linked to this one. environment is the one the box started with, as sandbox_start returns it: connections[] says which connector is online, its rttMs and which hosts go through it; services[].notable the settings to check first; activeBoxes your other live boxes on it, which may be changing the same data. goal is what the box is for, as given to sandbox_start, and steps[] the last 30 things done in it, oldest first (commands, directories and the notes given with them, no output; a foreground command's exitCode, signal and timedOut, and error when the platform failed): read both before picking up a box another conversation left. agent says whether the conversation that last used the box is still at it: state working, away (still open, busy elsewhere), left (closed) or idle (unused for an hour), and thisConversation when that conversation is you; restarting your own client also shows left with a new identity, so a box you used before the restart is yours to continue; working or away without thisConversation means another conversation may come back to it, so ask the person in this conversation before taking it over. fromHuman, when present, is what the person left for you in the app; only the conversation holding the box gets it, once. stopsAt is when the idle rules stop the box for good (/work gone) unless something uses it before then; restorableUntil, on a frozen box they stopped, is until when sandbox_start with restore brings it back. disk shows what fills the box: free space, each /work directory, caches, /dev/shm and Docker; nothing is cleaned for you. freeze says when it freezes and what keeps it awake; services[].lastProxyError why its URL last failed; fields returns only the fields you name (its description lists more).

sandbox_stop

ChatGPT
Stop a box and release its machine. Everything under /work is gone afterwards. Call it as soon as you are done with a box and there is nothing for the person to try (use sandbox_review when there is): a box you leave running shows in their app as "AI stopped" until someone decides what to do with it.

sandbox_takeover

ChatGPT
Ask a person to take over the box's screen for something only they can do before you can go on: signing in, a CAPTCHA, a code sent to their phone. Blocks until they hand it back (returns their note) or the link expires: 30 minutes after this call, or after they first open it if that is later. While they work, sandbox_shot of the screen, a window or a URL still answers, with takeover: true. To have them try what you built, phone and desktop apps included, use sandbox_review.

sandbox_versions

ChatGPT
List published versions. Start another box with services[].version (label or versionId) to run one under a name.

sandbox_wire

ChatGPT
Point a service name inside the box at your process in the box (mode box: name:port reaches targetPort) or at externalBaseUrl (mode external). Only the routing changes, so your process can already be running. With port (and targetPort) it declares a new name instead; with port and fromBox the name links to another of your boxes. With web and no mode it only marks whether a person opens the service in a browser, which gives it its own URL. With scenePaths instead of a service, the box forwards those paths on sceneUrl to externalBaseUrl, so a page it serves can call the environment's API same-origin. Returns the whole wiring table.

Capabilities

WritesInteractive

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/parallelsandbox"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/parallelsandbox)