PiPilot docs

PiPilot is an AI fullstack build hub. You describe what you want in plain language and the PiPilot agent builds it for you — a real, running project, with a live preview you can click through as it takes shape, and a path to ship it. Not just websites: web apps, mobile apps, desktop apps, and back ends.

It is for founders validating an idea, designers shipping a working prototype, developers scaffolding a project in minutes, and anyone who can describe what they want but would rather not wire it up by hand. If you have reached for tools like Lovable, Bolt, v0, or Replit, PiPilot is the alternative — it writes real code into real files, runs a real dev server, and deploys to a real URL.

Unlike a code snippet generator, PiPilot owns the whole loop: it plans, edits the filesystem, installs dependencies, runs the app, inspects the result, fixes its own mistakes, and keeps iterating with you in chat until the app is what you wanted.

Going from idea to a working app takes about a minute.

1. 1

   Sign in

   Continue with Google, GitHub, or an email and password. Your account unlocks the building agent and links your project storage.

2. 2

   Describe your app

   In the prompt box, write what you want to build — for example, “a habit tracker with daily streaks and a calendar view.” Be as vague or specific as you like.

3. 3

   Watch it build

   The agent plans the work, writes files, installs dependencies, and starts a dev server. The preview updates live as each change lands.

4. 4

   Refine by chatting

   Ask for changes in plain language — “make the header sticky,” “add dark mode,” “use a softer color palette.” The agent edits the existing code in place.

5. 5

   Deploy

   When you are happy, deploy to a public URL and share it. No build config or API keys required.

Behind the chat, the agent operates like a developer at a terminal. It reads and writes real files in your project, installs the packages it needs, and runs a development server so the app is genuinely running — not mocked.

Every edit triggers a hot reload, so the preview reflects changes the moment they are written. You can flip between two views at any time:

• Preview — the live, interactive app exactly as a visitor would see it.
• Code — the full file tree and source the agent is editing, so nothing is a black box.

To keep a build visually consistent, the agent maintains a design system in .pipilot/design.md. This file captures the project's colors, typography, spacing, and component conventions, and the agent reads it before adding new screens so the whole app stays coherent.

You do not have to start from a blank page. PiPilot ships a template gallery of polished, working starters — 6+ templates for every web framework (React, Vue, Svelte, Vite, Next.js, Nuxt, Angular, and fullstack), plus blank scaffolds — each responsive, in light and dark, and ready to extend by chatting.

1. 1

   Open the gallery

   Pick Start from a template in New Project, or browse the public /templates page.

2. 2

   Choose one

   Filter by framework, preview the design, and hit “Use template.” PiPilot creates the project — merging the framework scaffold under the template files so it is buildable from the first second.

3. 3

   Make it yours

   Describe the changes you want and the agent edits the template in place, exactly as it would any project.

Publish your own. Turn any project into a template others can start from. A Community tab in the gallery surfaces what other builders have shared, and ✨ Write with AI drafts the template's description from your project's own .pipilot/project.md and design.md.

PiPilot is not limited to single-page websites. The agent can scaffold and ship several kinds of real, full-stack projects — pick a starting framework and describe the rest:

• Web apps — Vite + React + Tailwind by default: dashboards, tools, landing pages, SaaS frontends, and prototypes.
• Mobile apps — React Native + Expo projects that run on iOS and Android, previewable on a real phone and shippable to the App Store and Google Play via Expo EAS.
• Desktop apps — Tauri and Electron apps packaged into Windows, macOS, and Linux installers.
• Backend APIs — Node.js back ends with Express or Hono: routes, middleware, and a database, ready to deploy as serverless functions.
• Python / FastAPI backends — async Python APIs that run in the cloud sandbox, with typed Pydantic models and auto-generated docs.
• CLIs — command-line tools with argument parsing and a publishable binary.
• npm packages & SDKs — typed libraries with a build step, ready to publish to the npm registry.

Each type comes with sensible defaults — TypeScript, a build pipeline, and the right entry points — so you start from a working project, not an empty folder. The agent knows the conventions of each and uses the matching package manager and commands.

Choose the React Native / Expo project type and PiPilot builds a true native mobile app. You get a live preview while you iterate, and the agent works with the Expo toolchain to wire navigation, native modules, and platform-specific behavior.

Preview on a real phone — free, no account. As you build, PiPilot exposes an Expo Go QR code. Install the free Expo Go app, scan the code with your camera, and your app opens live on your device with hot reload — every change you ask for shows up instantly in your hand. No build, no signing, no developer account required.

Real builds — Android APK & iOS. When you are ready to ship, PiPilot produces real device builds through Expo EAS, the cloud build service that compiles your project into an installable .apk for Android or a signed iOS build. You can sideload the APK, hand testers a link, or proceed straight to the stores.

Submit to the stores. With your store accounts connected, PiPilot runs eas submit to publish your app to Google Play and the Apple App Store — the agent uploads the build and pushes it into review for you.

To build and ship, connect these in the Integrations hub:

• Expo (EAS) — required for cloud builds and submissions.
• Apple Developer — an App Store Connect API key, to build and submit iOS apps.
• Google Play — a service-account key, to publish Android apps.

# PiPilot runs these for you on EAS
eas build --platform android   # -> installable .apk
eas build --platform ios       # -> signed iOS build
eas submit --platform android  # -> Google Play
eas submit --platform ios      # -> Apple App Store

PiPilot builds real desktop applications with Tauri and Electron. You describe the app, iterate on it in preview, and when it is ready PiPilot packages it into native installers.

Cross-platform installers, built in the cloud. PiPilot compiles your app on a GitHub Actions matrix, producing installers for Windows, macOS, and Linux in one run — including a macOS build even if you do not own a Mac, because the build runs on a hosted macOS runner.

Delivered to your Google Drive. When the matrix finishes, the finished installers (a Windows .exe/.msi, a macOS .dmg, a Linux .AppImage/.deb) are delivered straight into your own Google Drive, ready to download and distribute.

Beyond Node, PiPilot builds Python back ends with FastAPI. Describe the API you want and the agent scaffolds typed endpoints, Pydantic models, and the auto-generated interactive docs that FastAPI ships with.

Because the in-browser runtime runs Node.js only, Python can't execute in the tab — so PiPilot auto-routes FastAPI projects to the cloud sandbox, where the agent installs dependencies, runs the server, and streams logs and responses back to you. You can build and test a real Python API from any device, including your phone. (This is unrelated to the Desktop apps build target, which packages Tauri/Electron installers.)

# A FastAPI endpoint PiPilot scaffolds for you
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items")
def create_item(item: Item):
    return {"created": item.name, "price": item.price}

Ask PiPilot for a promo, teaser, or product demo and it renders a real, narrated MP4 in the cloud, then publishes it to your Google Drive as a shareable link. You describe the video in plain language; the agent writes the storyboard and produces the finished clip.

• Themed motion cards — unique title/outro cards per video, with custom fonts, colors, and on-screen typewriter text.
• Accurate visuals — scene images generated to your prompt (on-brand), or pulled from a huge built-in stock library; live video b-roll via Pixabay when connected.
• Live product demo — a screencast scene drives your deployed app with a visible cursor: it signs in, clicks through features, and records the real thing.
• Voiceover & music — AI narration in 20+ voices, background music that ducks under the voice, and burn-in captions.
• Finished & shareable — 1080p, an auto-generated thumbnail, and a durable Google Drive URL.

PiPilot runs your project in one of two environments, and picks the right one automatically. Both give you a live preview; they differ in where the app actually executes. (This is separate from the Desktop apps build target — that's about packaging Tauri/Electron installers, not about where your project runs while you build.)

In-browser runtime. On a desktop browser, PiPilot boots a Node.js environment directly inside the tab — nothing is installed on your machine and your code never leaves the browser. This path requires a Chromium-based desktop browser (Chrome, Edge, Brave, or Arc) and uses npm to install dependencies. Safari, Firefox, and mobile browsers don't support it, so PiPilot routes those to the cloud path instead.

Cloud sandbox. On mobile, in non-Chromium browsers, and for any stack that the in-browser runtime can't run, PiPilot runs the project in a cloud sandbox on the server. This means you can build, run, and preview a full app entirely from your phone — the heavy lifting happens in the cloud and streams back to you. The cloud sandbox uses pnpm ( npm is not available there).

# In-browser runtime (desktop, Chromium-based browser)
npm install
npm run dev

# Cloud sandbox (mobile / non-Chromium / non-Node stacks) — agent does this for you
pnpm install
pnpm run dev

The preview window shows your app running in real time and updates on every change. It behaves like the real thing — you can click, type, and navigate to test flows as the agent builds them.

Alongside the preview, you get the console and terminal output: build logs, dev-server messages, and any runtime errors the app throws. This is the same signal the agent sees.

Crucially, the agent self-verifies. After making a change it watches for errors — a failed import, a type error, a crashed component — and when it finds one it diagnoses the cause and applies a fix, then re-checks, often without you needing to ask. You stay in the loop and can always jump in, but the agent does the tedious error-chasing for you.

Sometimes the fastest way to describe a change is to point at it. With visual edit, you click an element directly in the live preview — a heading, a button, a card — and PiPilot maps it back to the exact component and line in your source.

From there you can type a precise instruction (“make this larger and centered,” “change this label”) and the agent edits the right file without you hunting through the tree. The inspector shows what you selected, so the agent always has the right target — no guessing, no scrolling through code to find the element you meant.

Mission Runners are autonomous cloud agents that take on a whole task end-to-end while you step away. A Mission Runner spins up a fresh cloud sandbox, runs an autonomous PiPilot agent against your current project — or a cloned GitHub repo — and works through the job: building features, deploying, or chasing down a bug.

Because they run in the cloud, missions keep going even if you close the tab. You launch one from the Missions tab, hand it an objective, and check back on its progress and results. It is the difference between pairing with the agent live and dispatching it to finish work on its own.

• Build — implement a feature or refactor across many files.
• Deploy — run the full build-and-ship pipeline to a live URL.
• Debug — reproduce, diagnose, and fix a reported issue.

You stay in control while a mission runs: spawn as many runners as you need, monitor their live progress, edit and resend an objective to redirect one, and queue follow-up tasks so a runner picks up the next job as soon as it finishes the current one.

For larger builds, a single agent can spawn background sub-agents that run in parallel. Each worker takes on part of the job — one scaffolds the data layer while another builds the UI, for example — and they coordinate by messaging each other directly.

The team also shares a common task list, so work is tracked, divided, and checked off as it completes. This lets a big feature be built in several streams at once instead of strictly one step after another, while still converging on a coherent result. You see the whole team's activity in one place and can redirect it at any time.

PiPilot streams the agent's work to you as it happens. Instead of waiting for a finished answer, you watch the reasoning, the file edits, the terminal commands, and the tool calls arrive token by token — so you always know what the agent is doing and why.

This live feed keeps long builds transparent and interruptible: if the agent heads in the wrong direction, you can see it early and steer, rather than discovering a wasted run at the end. Streaming also keeps cloud builds responsive, with progress flowing back from the sandbox in real time.

PiPilot speaks the Model Context Protocol (MCP), the open standard for connecting AI agents to external tools and data. You can connect 130+ integrations — GitHub, Stripe, Supabase, Slack, Figma, and many more — to the building agent.

When you connect an MCP server, the agent gains that service's tools and can use them directly inside a build: open a pull request, create a Stripe product, query a Supabase table, post to Slack, or pull a Figma frame. Connect only what you need, when you need it — each integration adds its tools to the agent's toolbox for that project.

The agent can drive a real cloud Chromium browser through a browse_web tool. You (or the agent) supply a short Playwright script, and it runs in a fresh headless browser to navigate, interact with, and test any URL — including your own live preview. It returns the console logs and screenshots so the agent can see the result and act on it.

This is how PiPilot can verify a deployed page actually renders, reproduce a bug by clicking through a flow, or capture a screenshot for review.

// browse_web: navigate, screenshot, and read the title
await page.goto('https://your-app.pipilot.dev')
await page.waitForSelector('h1')
const title = await page.title()
await page.screenshot({ path: 'home.png', fullPage: true })
console.log('Loaded:', title)

PiPilot ships with DeepWiki wired in as a built-in MCP server — always on, no token, nothing to connect. It gives the agent a way to actually understand any public repository on GitHub instead of relying on memory.

With DeepWiki, the agent can, mid-build:

• Read a repo's structure — map out how a project or library is organized.
• Read its docs — pull the documentation and wiki content for a repository.
• Ask a question — get a grounded answer about how a library works or how to use an API.

The upshot: when you ask PiPilot to build with a specific library, it can check how that library actually behaves and write code against the real API — fewer guesses, fewer hallucinated methods. It sits alongside any MCP servers you connect yourself.

Love how a site looks? Point the agent at it. The clone_ui tool takes any public URL, renders the live page in a cloud browser, and studies the real thing — not a screenshot guess.

It extracts the page's actual design and hands it to the agent to rebuild in your project:

• Design tokens — colors, typography, and spacing lifted from the live styles.
• Components & layout — the recurring building blocks and how they are arranged.
• Fonts & assets — font sources and images the page loads.
• Responsive pass & screenshot — how it behaves across sizes, with a capture to confirm what was seen.

From there the agent rebuilds that design inside your project — a genuine starting point you then shape with chat.

Every project has a real File Manager, backed by your own Google Drive. It is a proper file browser, not a flat list — organize, upload, and preview your project's files without leaving PiPilot.

• Folders — create, rename, and delete folders with breadcrumb navigation.
• Upload — drag files straight in from your desktop.
• Batch download — multi-select any set of files and download them as a ZIP.
• Find things — search and sort, and browse a grid view with real image thumbnails and an image preview.

Bring your own material into a build. Attach images and documents right in the chat and the agent takes them into account — images through vision, and documents (PDF, Word, spreadsheets, text) as extracted text — so “match this mockup” or “use the figures in this brief” just works.

Save an asset into the project. The save_asset tool imports an uploaded image, logo, or file straight into your project as a real asset the running app uses at runtime — the bridge that makes “use this logo in my app” actually ship the logo.

Every app you build gets PiPilot DB — a real, production-grade Postgres database, built in. It is provisioned in seconds, with no signup and no config. There are no connection strings to copy, no dashboard to set up, and no separate account to create.

Out of the box you get genuine SQL tables, Auth, and a REST Data API over your data. The building agent can create tables and run SQL for you as it builds — so when you ask for “a table of orders with a status column,” it shapes the schema and wires the queries without you touching the database directly.

• Real Postgres — not a toy store. Full SQL, relations, indexes, and constraints.
• Auth + REST Data API — sign-in and a queryable API over your tables, ready instantly.
• Agent-driven — the agent creates tables and runs SQL for you as part of the build.

Every project is a real Git repository. PiPilot runs genuine version control in the builder — the agent (and you) can commit, check status, read the log, and restore files — so your history is durable and you can always roll back to a known-good state.

You can connect a GitHub remote and push and pull directly. That makes it easy to take a project out of PiPilot, collaborate with a team, or hand it to a Mission Runner that clones the repo, does the work, and opens a pull request.

Every project type has a path to ship — the agent runs the build and the right pipeline for you, with no local toolchain and no login dance.

Web apps — one-click deploy. PiPilot ships your app with a free, keyless instant deploy out of the box: it runs the production build and returns a live, shareable HTTPS link in seconds, with no account or API keys to configure. It's static frontend hosting — need data or auth? Add PiPilot DB (an instant Postgres with auth and a REST API). Want a permanent home on your own infrastructure? Connect a provider and deploy to Vercel, Netlify, or Cloudflare instead — full backend & serverless support, add a custom domain in a few clicks, and re-deploy any time.

Mobile apps — to the stores. PiPilot builds a real Android .apk and iOS app via Expo EAS, lets you preview live on a phone through Expo Go, and submits to Google Play and the Apple App Store with eas submit. See Mobile apps.

Desktop apps — installers to Drive. A GitHub Actions matrix produces Windows, macOS, and Linux installers in one run and delivers them to your Google Drive. See Desktop apps.

Hands-free shipping. A Mission Runner can run the whole build-and-deploy pipeline in the background, so you can dispatch a release and walk away.

Want a plain, shareable web address without connecting a hosting provider? Publish a static site to a free *.pipilot.dev URL in one click. PiPilot builds your project and serves it live on PiPilot's own edge.

Under the hood the built site is stored in your own Google Drive and served through the PiPilot edge, so hosting costs you nothing and the files stay yours. Each published site gets SEO and social meta, an AI-generated logo and OG image, and optional custom domains.

PiPilot Host is our proprietary full-stack hosting engine — a Vercel alternative where the AI doesn't just build your app, it ships it. Where Instant web hosting serves a static site, PiPilot Host deploys a live frontend and a serverless backend on the same domain — with a database, object storage, and managed secrets — in a single deploy, with no separate account or config.

Reach for PiPilot Host when your app needs a real backend: a SaaS, a dashboard, a CRUD tool, a form collector, anything with data and auth. Just ask the agent to deploy — it writes the backend, provisions the data plane, deploys, and polls the build until it reports ready, fixing validation errors on its own.

Start in one click. Pick “PiPilot Host Fullstack” in the composer (or New project → Full-stack hosting) and you begin on a working scaffold already wired to the platform SDK. The agent edits real files like any project; a local preview renders the UI instantly, and the Publish button packages the whole app — frontend, backend, and images — and ships it (no deploy config, no slug to pick). Add SEO meta and a custom domain from the same panel.

• Frontend + backend, one deploy — no separate API host, no CORS setup.
• Database & storage included — a typed SDK for query/insert/update/delete and per-app object storage from the first deploy.
• Managed secrets — add a key (e.g. Stripe) and PiPilot mints a one-time entry link your user fills in; the value is bound server-side and never touches the browser or the model.
• Custom domains + automatic TLS, and versioned deploys with instant rollback.
• Secure by design — per-user isolation enforced server-side and a tamper-verified data plane that rejects writes if the deployed backend code is altered.

The template & SDK. A PiPilot Host project is a Vite + React + TypeScript frontend with a serverless backend in backend/index.ts. The platform injects @appdeploy/client (frontend) and @appdeploy/sdk (backend) — you don’t add them to package.json. The backend is a router of handlers; the frontend calls it with api (neverfetch):

// backend/index.ts
import { router, json } from '@appdeploy/sdk';

export const handler = router({
  'GET /api/todos':  [async () => json(await db.query('todos', {}))],
  'POST /api/todos': [async ({ body }) => json({ id: await db.add('todos', [body]) })],
  // auth: requireAuth() populates ctx.user — no custom JWT needed
  'GET /api/me': [requireAuth(), async ({ user }) => json(user)],
});

// src/App.tsx (frontend) — call the backend with api, never fetch
import { api } from '@appdeploy/client';
const { data } = await api.get('/api/todos');
await api.post('/api/todos', { title: 'Ship it' });

• Database — a key-value-with-tables store: db.add / query / get / update / delete. No SQL, no migrations, no connection strings.
• Auth — requireAuth() middleware + ctx.user and scopes. Don’t hand-roll JWT/bcrypt.
• Storage & secrets — storage.upload / url (signed URLs) and secrets.readSecret() (values entered out-of-band, never in code).
• Rules — SPAs use HashRouter; the local Preview runs the frontend only (backend calls are mocked) — deploy to see the real backend.

Learn more on the PiPilot Host overview.

The Launchpad is a weekly, Product-Hunt-style competition for apps built and published with PiPilot. Browse the current week at /showcase, or open Launchpad in the /app sidebar.

• Submit — enter one of your own published PiPilot apps into the current week.
• Nominate — anyone can nominate anyone's published app by its address (<slug>.pipilot.dev), not just their own.
• Vote & comment — signed-in users upvote or downvote an entry (a net score) and leave comments; you're prompted to sign in only when you try to vote or comment.

Prizes & the weekly cycle. When a week's voting closes, the top 3 entries by net score win bonus build hours — 1st +20h, 2nd +10h, 3rd +5h — plus a permanent spot on the Wall of Fame. A new week then opens automatically, so there's always a current round to enter or vote in.

The Connect your stack hub is where you link the services PiPilot builds, deploys, and ships with. The point is full control: connect your own accounts and everything lands in your infrastructure — your URL, your data, your billing — not ours.

Connect once, and the agent can use the service inside any build:

• Hosting — Vercel, Netlify, and Cloudflare: deploy to your own account and add a custom domain.
• GitHub — push code, open pull requests, and power the desktop installer build matrix.
• Databases — Supabase and PiPilot DB (Postgres): the agent provisions tables and wires queries against your database.
• Payments & email — Stripe for checkout and products, Resend for transactional email.
• Mobile & store delivery — Expo (EAS), Apple Developer (App Store Connect API key), and Google Play (service-account key) for builds and submissions.

Under the hood, connecting a provider securely hands its access token to the agent's cloud sandbox, so headless CLIs (wrangler, vercel, netlify, gh, supabase, stripe, eas) run with no login flow. Combined with MCP integrations, your whole stack becomes available to the agent inside a build.

Your projects are stored in your own private Google Drive, inside a dedicated app folder. We never host your files — they live in your account, which means storage is effectively free, your work is available on every device you sign in from, and you remain in full control of your data.

Sessions persist across devices and reloads: pick up a project on your laptop exactly where you left it on your phone. If you signed in with Google, Cloud Sync connects automatically. If you signed in with GitHub or email, connect it from Settings → Cloud Sync in one click. Once connected, projects sync transparently as you build.

Sign in with whichever method suits you: Google, GitHub, or a classic email and password. Google sign-in has the bonus of wiring up Cloud Sync for you on the spot.

Your account is also what authorizes the building agent: the LLM API that powers PiPilot is gated behind your sign-in, so requests are always tied to a real account. There are no API keys for you to manage.

Your Profile is the home for your account. Open it from the user menu to manage who you are and what you have.

• Identity — edit your display name.
• Plan & usage — see your current plan and build-hour usage at a glance.
• Referrals — your referral stats, your bonus balance, and who referred you.
• Connected accounts — review and manage the providers you have linked.
• Shared with you — an inbox of projects other people have sent you to claim.

Hand a whole project to another PiPilot user by email. PiPilot confirms the recipient is registered, then packages the project — text files and binary assets — and sends it over. They accept from their Profile and get their own independent copy in one click, uniquely renamed so nothing collides with their existing work.

Under the hood the transfer travels through a transient private GitHub repo in the sender's account, which is automatically cleaned up once the copy is claimed (or swept on a short TTL), so nothing lingers.

Invite friends and earn bonus build hours. Share your personal referral link; when someone you referred first subscribes to a paid plan, you earn bonus hours and they get a welcome bonus too — credited automatically, never gamed client-side.

Bonus hours stack on top of your plan allowance everywhere usage is metered, so they simply extend how much you can build. Anyone who arrives from an invite sees a clear welcome and bonus prompt.

Is it free?

Yes — you can build for free, and the instant deploy gives you free static hosting with a live shareable link. Add PiPilot DB for data, or deploy to your own Vercel/Netlify/Cloudflare for a full backend. Storage uses your own Google Drive, so there is no file-hosting cost.

Can I build on my phone?

Yes. On mobile, PiPilot runs your project in a cloud sandbox, so you can build and preview full apps from a phone. The agent uses pnpm there automatically.

Can I build a mobile app, not just a website?

Yes. Choose the React Native / Expo project type to build a true native app. Preview it live on your phone for free with Expo Go, build a real Android APK and iOS app via Expo EAS, and submit to Google Play and the App Store — no Xcode or Android Studio required locally, and you can build for iOS without owning a Mac.

Can I build a desktop app?

Yes. PiPilot builds Tauri and Electron apps and produces Windows, macOS, and Linux installers on a GitHub Actions matrix (including macOS without a Mac), delivered to your Google Drive.

Can I write a backend in Python?

Yes. PiPilot builds Python / FastAPI back ends that run in the cloud sandbox, so you can develop and test them from any device, including your phone.

Where is my data?

In your own private Google Drive app folder. We never host your project files, and access is scoped to the folder the app creates. With "Connect your stack," deploys, databases, and billing live in your own accounts too.

What can I build?

Web apps, React Native/Expo mobile apps, Tauri/Electron desktop apps, Express/Hono and Python/FastAPI back ends, CLIs, and npm packages/SDKs — including apps that need auth, a Postgres database, or file storage.

How do I deploy?

Ask the agent to ship, or use the deploy action. Web apps publish with a free instant deploy (or to your connected Vercel, Netlify, or Cloudflare account) and return a live URL; mobile apps build and submit to the stores via Expo EAS; desktop apps produce installers in your Google Drive. A Mission Runner can do any of this in the background.