Shipvo
Simüle edilmiş bir telefonda React Native uygulamasını açın: ekranı okuyun, dokunun, yazın ve cihaz durumunu ayarlayın.
Barındırılan MCP Sunucusu
npx add-mcp 'https://sim.shipvo.dev/mcp'Claude Code, Codex, Cursor ve daha fazlasına kurulur
Dokümantasyon

Shipvo: build once, publish for people and AI agents
One React Native app, two places it runs. People get a native Android or iOS app from the stores, kept current with signed over-the-air updates. AI agents get the same release in a phone-sized simulator they can see and operate over MCP, with no device, including native features (camera, location, biometrics, payments, notifications). Every claim about the simulator is measured against real Android and iOS and published.
Shipvo was briefly called PureNative. The hosted control plane is
api.shipvo.devand the hosted simulatorsim.shipvo.dev; the olderpurenative.workers.devaddresses keep answering for apps whose shell was built against them.
Three pillars:
- Publish. Signed OTA updates (64 KB patches, crash-loop rollback, staged rollouts), a built-in owner admin at
/app/<id>/admin, and a control plane you can self-host on Cloudflare. - Simulate.
@shipvo/mcpopens any Shipvo app for an agent: accessibility tree with refs, tap/type/scroll/back, screenshots.@shipvo/devicegives apps one device API, real on phones and simulated in the simulator, with Android- and iOS-worded system sheets the agent answers like a person. Simulation is explicit: every simulated event is logged as simulated and no simulated payment or fingerprint is ever presented as real. - Verify. The parity harness runs the same flows on the simulator, an Android emulator and an iPhone simulator and compares every screen. Current result, measured on an Android emulator and an iOS Simulator in CI: 100% actionable parity across the 13 screens of the two purchase flows on Android and iOS, meaning the same actionable elements with the same roles and labels on every screen. Full method and results:
docs/parity-results.md.
Website · Docs · Blog · Shipvo vs Expo · Pricing · Roadmap
Measured. OTA numbers come from a real low-end phone (Redmi 9A, 2 GB RAM):
docs/spike-results.md. Agent results:docs/agent-gate-results.md. Simulator-vs-device parity:docs/parity-results.md. Native-feature parity (camera, location, permissions, payment prompt) is measured on the Android emulator and the iPhone simulator in CI. The iOS OTA runtime is verified on the iOS Simulator in CI on every change to it (fetch, verify, stage, reload, cold start). Measured there on 5 Nov 2026 (docs/spike-results.md, run 41979433300, median of 3, local control plane): launch to new release running and healthy 4.2 s (iOS Simulator; OTA timings on the Redmi 9A are in the same file), full 1.87 MB bundle download 157 ms, apply 266 ms. A first-update bsdiff patch from the embedded bundle was 83,999 bytes against a 1,996,082-byte bundle, 573 ms from last byte to healthy (run 42087991990).
Why Shipvo
Every change to a native mobile app normally means a new build, a store submission, a review, and then waiting for users to update. Many never do. Shipvo separates what has to go through the store from what doesn't:
| Layer | Ships through | Contains |
|---|---|---|
| Native shell | App Store / Google Play | Native modules, declared permissions, the signing trust root |
| Core runtime | Over the air, signed | The app's JavaScript (Hermes bytecode) |
| Screens and add-ons | Over the air, signed | New screens, features and fixes built on capabilities the shell already declares |
Updates are interpreted JavaScript running on native capabilities the shell declares up front. The app never asks for a permission it hasn't declared.
Features
- Signed OTA updates: Ed25519 signatures, verified natively on the device against a public key built into the app. An update can't replace its own trust root.
- Integrity checks: SHA-256 and size are verified before a bundle is staged; staging is atomic.
- Crash-loop protection: a release that fails to boot 3 times is discarded automatically, and you can roll back to the previous release in one call.
- Staged rollouts: cohort bands (1%, 10%, everyone) served as static signed pointers from the edge, with no device registry.
- Safe rollbacks with stored data: a release declares a
stateVersion, and a rollback to an older stored-data format is refused unless you pass--allow-state-downgrade(Rollbacks and stored data). - Key rotation:
shipvo keys rootcreates an offline root key, andshipvo keys rotate signanduploadchange keys without a new store build; rotations show inshipvo audit(Key rotation). - Telemetry for every release: applied, reverted, cold-start time, download size and time.
- Control plane you can host yourself: on Cloudflare Workers (KV, D1 and R2) or with Docker (
docker compose up), with backup and restore commands (self-hosting). - Admin per app at
/app/<id>/admin: live content, prices, offers, orders, history, publish to every phone in seconds; the same typed owner commands are available to agents with a token. - Agent-operable apps: every app exposes typed commands and a UI simulator;
@shipvo/mcpplugs both into Claude, Cursor, Claude Code or PiPilot. - Simulated device:
@shipvo/deviceruns camera, location, biometrics, payments, notifications, share and network on phones (Expo modules) and in the simulator (system sheets in the accessibility tree, state set by the agent). Each capability declares its support level: real, simulated or unavailable. - Any Expo app, from the shell:
npx -y @shipvo/cli session start androidorsession start iosopens any Expo app on a headless phone with no setup. Your coding agent reads the screen, taps, types, saves screenshots and a video of the phone in its frame with the status bar, and the session stops on its own (session). - Shipvo Phone:
shipvo run androidorshipvo run iosopens your app in an Android or iPhone frame in your browser, with live reload, a notification shade, Settings, a Browser app, network profiles and a device panel. No emulator or Xcode needed (run). - Describe an app and it appears: your assistant calls
create_appandupdate_appto build a spec app on the phone, thenarrange_apps,schedule_app,refresh_appandapp_activityto place it, time it, refresh its data and read what changed, on Android and iOS (Describe an app, Phone apps). - Email sign-in without a mailbox: every session has a private inbox, so a test or an agent reads the code or magic link and finishes the sign-in on Android and iOS (Test an email sign-in).
- Assistants talk to each other: ChatGPT, Claude and others on one phone message each other and hand over tasks in the Assistant Inbox, on Android and iOS (Phone apps).
- A2UI on Shipvo Phone: an agent describes a screen as A2UI 1.0 data and Shipvo Phone draws it on an Android or iPhone frame, sends taps back to the agent, and changes the screen while it is open (a2ui).
- Bug-catch benchmark: 23 seeded app bugs, counted on Android and iOS, with the method and the command to run it yourself (bug-bench).
- A whole phone for assistants: reminders, search across the phone, share sheet and clipboard, Wi-Fi and airplane mode, a permission log, whole-phone backup and an accessibility audit, the same on Android and iOS (Phone apps).
- Playground in your browser: the sample app on an Android or iOS phone, with the device API, signed updates and up to 12 phones in one shareable link, no install (Playground).
- Lumi:
shipvo lumi android|iostests your app while you watch: it walks every screen, reports findings with replay buttons, shows coverage and saves findings as tests (Lumi). - Pull request check:
shipvo ci init --checkruns your tests and an explore pass on every pull request, with before and after screens of Android and iOS in the comment (PR check). - Behaviour timeline: the app admin compares how each release and pull request behaves on Android and iOS (timeline).
- Real devices too:
shipvo test --device agent-deviceruns the same tests on an Android emulator or iOS Simulator through Callstack's agent-device (testing). - Score an agent:
shipvo eval runruns any agent or model on a task and measures pass rate, steps, time, errors and retries on Android and iOS (eval). - Move over in one command:
shipvo migrate --planand--applyswitch an app from Expo EAS Update or CodePush (EAS Update, CodePush). - Design skill: a runnable theme generator, screen checker and anti-generic lint in
skills/shipvo-design.
Start
npm create shipvo@latest myshop -- --template shop && cd myshop && npm install
npx shipvo run android # your app on Shipvo Phone in the browser (npx shipvo run ios for the iPhone frame)
npx shipvo lumi android # Lumi tests it while you watch
npx shipvo agents setup # connect your coding agent over MCP
npx shipvo publish # ship changes over the air to Android and iOS
Templates: blank, content and shop.
Guides: Build your first app · Tutorials · CLI · Test your app in CI · Test with an assistant · Test an email sign-in · Store release · Frameworks and adapters · Migrate from CodePush · Migrate from Expo EAS Update · Taking real orders · Device API · Agents and MCP · Self-hosting the control plane · Threat model for signed updates · measured results: OTA on a 2 GB phone, simulator vs device parity, agent gate.
Use Shipvo with your coding agent
Install the Shipvo skill. It teaches your agent to set up Shipvo, run the app on Shipvo Phone, test it, publish and roll back signed updates, start the store path and record a demo.
- With npm:
npx skills add shipvo/shipvo --skill shipvo -g - Without:
curl -fsSL https://shipvo.dev/install.sh | bash(macOS, Linux) orirm https://shipvo.dev/install.ps1 | iex(Windows PowerShell); more on shipvo.dev/setup - Or paste this to your agent: "Set up Shipvo in this project: run
npx -y @shipvo/cli agents setup, then follow what it prints."
The skill is in skills/shipvo. A test checks that every command it names exists in shipvo help.
Use an app as an AI agent (no phone)
In your app, npx shipvo agents setup writes the MCP config for your coding agent. To add it by hand, install it in the app (npm i -D @shipvo/mcp) and point the agent at the local server, for example in Claude Code:
claude mcp add shipvo --env PN_SIM=http://localhost:4545 -- node node_modules/@shipvo/mcp/dist/server.js
Start the simulator with npx shipvo sim. When shipvo run android or shipvo run ios is open, open_app drives that phone and you watch the agent work.
Then: open_app("tide@latest") returns a phone-sized session and the first screen as an accessibility tree with refs; tap, type, scroll, back and screenshot act on it; set_device decides what the phone has (a barcode in front of the camera, a location, whether the fingerprint matches, whether a payment is approved, network off); device_log reports every device event, all marked simulated; end_session returns the steps taken and the orders the app sent. tide@r13 opens exactly the release phones are running; tide opens a local build. Full tool list: packages/mcp/README.md.
See it live: two phones playing chess, an Android phone and an iPhone, with every square labelled for agents (run it with your own agents).
What the agent sees is what a person with a screen reader would: only the items of a rail that are on screen (swipe to see more), nothing behind a modal sheet, system dialogs worded as Android or iOS word them.
How a release reaches phones and agents
shipvo publish Build Hermes bundle → SHA-256 → bsdiff patches → sign pointer (Ed25519)
│ Build web artifact of the same commit (platform adapters only)
▼
Cloudflare edge /p/{app}/{shell_major}/{band}.json (signed envelope, ETag)
│ /b/{app}/r{release}.hbc (immutable bundle, bsdiff patches)
│ /w/{app}/r{release}/ (the same release for agents)
├──────────────────────────────┐
▼ ▼
Device runtime (Kotlin, Swift) Simulator / sim.shipvo.dev
verify → download → verify open_app("tide@r13") → accessibility tree
→ stage → reload → healthy → tap/type/scroll → device sheets → report
or revert after 3 failed boots
▼
Telemetry POST /t → D1; orders POST /o/{app} → D1
Repository layout
| Path | What it is |
|---|---|
packages/schema | Contracts: shell manifest, add-on manifest, release pointer, signed envelope, gate report, change log, telemetry (Zod) |
packages/cli | shipvo CLI: init a new app or adopt an existing one, sim it, publish / rollback signed releases, store help, signing keys (docs/cli.md) |
packages/runtime | @shipvo/runtime: the native OTA runtime for Android (Kotlin) and iOS (Swift): verify, patch, stage, apply, crash-loop rollback and the config plugin that pins the trust root |
packages/sim | @shipvo/sim: the simulator (phone-sized headless browser, accessibility tree, simulated device, mock backend) |
packages/mcp | @shipvo/mcp: the MCP server agents use to open, see and operate apps, control the simulated device, and run owner commands |
packages/test | @shipvo/test: typed end-to-end tests that run your app in the simulator, in Vitest or any runner, headless in CI (docs/testing.md) |
packages/device | @shipvo/device: one device API (camera, location, biometrics, payments, notifications, share, network), real on phones, simulated in the simulator, plus Metro aliases for raw Expo imports |
packages/store | @shipvo/store: drafts Play Data safety answers and a privacy policy from shipvo.json, and checks store screenshot sizes (docs/store.md) |
packages/spec | @shipvo/spec: the JSON Schema for shipvo.app/v0 app specs and a validator that returns errors and warnings with a JSON path and a suggested fix |
packages/shipvo, packages/create-shipvo | shipvo and create-shipvo: the CLI under its short name (npx shipvo, npm i -g shipvo) and npm create shipvo; both forward to @shipvo/cli |
packages/capacitor | @shipvo/capacitor: signed web bundles for Capacitor apps: release decisions, Ed25519 + SHA-256 verification and rollback rules |
packages/mcp-tools | @shipvo/mcp-tools: the registry of every Shipvo MCP tool (name, description, input schema, error codes), shared by the local and hosted servers (docs/mcp-tools.md) |
services/control-plane | Hono worker on Cloudflare: pointers, bundles, web artifacts, content, orders, telemetry, admin, owner API |
services/sim | Hosted simulator Worker: one sandbox per API key, the same MCP tools over HTTPS (sim.shipvo.dev) |
services/site | shipvo.dev: landing page and the public app marketplace |
apps/tide-and-tackle | Sample shop app built on the packages above, plus the device drivers and the parity harness (sim/) |
apps/chess | Chess app with a labelled board for agents, and the two-phone demo (pnpm --filter chess demo) |
apps/capacitor-sample | Capacitor sample app, built for Android and iOS in CI |
docs/ | Guides, tutorials, roadmap and measured results (spike, agent gate, parity) |
scripts/ | CI helpers: first-run, Android and iOS end-to-end runs, simulator bench |
skills/shipvo-design | Design skill with runnable checks |
Store release
For a first store release, shipvo store setup and shipvo store status say which Google Play and Apple accounts to open and what to do next. shipvo store details --dry-run drafts Data safety answers and a privacy policy from shipvo.json. shipvo store screenshots renders store-sized screenshots in the simulator (fast mode, not the native UI). Nothing is uploaded and no store credentials are read. Details: docs/store.md.
Frameworks
React Native with Expo, and bare React Native apps (shipvo init inside the app; it writes the Android manifest and Info.plist values after you confirm). Apps on expo-updates or CodePush move over with shipvo migrate. Capacitor apps build signed Android and iOS binaries in your own GitHub Actions (shipvo ci init --framework capacitor) or on EAS (shipvo eas setup): docs/capacitor.md. How a framework adapter works: docs/adapters.md.
Try the sample app
- Download the latest
tide-and-tackle-shell.apkfrom Releases and install it on an Android 7+ phone. - Edit
apps/tide-and-tackle/src/release.tsand runshipvo publish(or push tomainand let thepublish-otaworkflow do it). It signs and publishes the release. - The app checks every 10 seconds while open, verifies the update, applies it, and logs the timings on screen.
- Change prices or the home screen at
/app/tide/adminon your control plane; the phone shows it in about 10 seconds. - Open the same release as an agent:
cd apps/tide-and-tackle && pnpm sim, thenopen_app("tide@latest")through@shipvo/mcp, orapps/tide-and-tackle/scripts/ui screenfrom a terminal.
Develop
pnpm install
pnpm -r test
pnpm --filter @shipvo/control-plane dev
Requires Node 22 and pnpm 10.
Compared with other OTA tools
Shipvo sits alongside tools like Expo Updates (EAS Update) and self-hosted CodePush servers, which replaced Microsoft App Center CodePush after it was retired in 2025. What Shipvo adds: a declared-capability shell manifest, signed add-ons, a per-app admin, cohort rollouts from static edge files, and apps that AI agents can operate.
License
Framework: Apache-2.0. The hosted control plane may be offered under a source-available license; self-hosting stays permitted.