PiPilot
Changelog

What’s new in PiPilot

Every release, in plain language — the features, fixes and announcements that make building from anywhere feel effortless.

20
Releases
54
Updates
201
Changes
v6.0
Feature

Just describe it: PiPilot now picks the right stack for you

The template picker is gone from the composer. Type what you want and PiPilot detects the project type, shows what it will build, and starts.

  • A plan chip (for example: Building: React web app with accounts and database) appears and starts automatically. Click Change to switch stack.
  • If your prompt is ambiguous, PiPilot asks one quick question instead of guessing.
  • Desktop apps are routed between Native SDK and Electron based on what the app needs (system tray, local files and Node modules point to Electron).
  • Honest heads-ups up front: payments need your Stripe keys, emails need a sending provider, SMS needs Twilio.
  • Prefer to choose yourself? Use Advanced, or type @expo, @electron and so on in your prompt.
  • Fixed: the agent could stop after writing a plan and ignore "yes, proceed". Approving a plan now starts the build.
Learn more in the docs
v5.9
Feature

A building screen while the agent sets up your project

The preview pane shows what the agent is doing while there is nothing live to show yet.

  • While the agent is setting up a project and there is nothing live to show yet, the preview pane now shows a PiPilot building screen instead of a blank panel: what the agent is doing right now, with a little in-flight humour in between.
  • The caption is real status first: the tool the agent is running, or the runtime phase (installing dependencies, starting the dev server). It steps aside the moment there is a live preview to watch.
Learn more in the docs
v5.8
Fix

A failed payment no longer costs you your plan

Failed-payment recovery with a 14-day grace window, a clearer picture when you hit the daily prompt limit, and two corrections to the pricing page.

  • A declined card no longer costs you your plan. If a payment fails we keep your plan running for 14 days, tell you what happened and which card it was, and give you a one-click link to pay the invoice with no sign-in. Pay it and everything restores immediately.
  • Previously the first failed charge moved you to the free plan the same day, even though the card was about to be retried automatically. That is fixed. Nothing is ever deleted, and only a payment left unresolved for 14 days changes your plan.
  • Running out of prompts for the day now gives you a clear picture instead of a dead end: what is spent, when it comes back, and what your files, preview and deploys can still do. On a paid plan, running out of premium prompts is named for what it is — standard prompts are unlimited, so the build carries on.
  • Two corrections on the pricing page. Annual billing is ten months up front for twelve, which is about 17% off; it had said 20%. And Cloud Hours only ever covered missions and cloud deploys, never previews — live previews are free and unlimited on every plan, including the free one.
Learn more in the docs
v5.7
Feature

Open a repo, work like it is yours: branches, pull requests and reviews

Opening a GitHub repository in PiPilot used to give you one thing — your changes pushed back to a working branch. Now it gives you the rest of the workflow. Switch and create branches, see how far ahead or behind you are, open a pull request, watch its checks, and read the review without leaving the chat. When a merge conflicts, nothing is changed and nothing is lost: you get the files, and one button hands them to the agent to resolve.

  • Open a pull request from the Version control panel or by asking the agent. If you do not have push access to the repository, it opens from a fork automatically.
  • Review comments and failing CI checks arrive in the chat with their file and line. "Address this" hands the whole set to the agent — no copy-pasting a review.
  • Real branches: list them, switch, or create one from any base, with live ahead/behind counts against the remote.
  • Commits pushed to your branch on github.com now merge back into your workspace on their own, with a real three-way merge.
  • A conflicting merge changes nothing at all. You get the list of files and can resolve them yourself, or let the agent read both sides and finish the merge.
Learn more in the docs
v5.6
Fix

PiPilot stops losing the thread

A set of fixes for the times PiPilot went and did the wrong thing, or quietly did nothing. The biggest one: when you reopened a project, the "where you left off" card could put its own suggestions into the chat as if you had typed them — so a stale idea from days ago became an instruction PiPilot had to follow. Those suggestions are now background context it can ignore when you ask for something else.

  • The resume card no longer writes suggestions into your message. It now carries them as context, clearly marked as something you did not ask for.
  • You can turn the resume card off entirely — PiPilot still gets the context, you just stop seeing the dialog.
  • Errors in your preview are sent to PiPilot automatically on your next message. The "Auto-fix" button is gone because there is nothing left to press.
  • PiPilot now knows which repository, database and deployment your project already uses, so it stops creating a second one beside the one you have.
  • If the connection drops mid-step, PiPilot picks the work back up instead of stopping with an error.
Learn more in the docs
v5.6
Feature

Pushing to GitHub is real git now

Pushing used to upload your whole project as an archive, which replaced everything in the repository. If you or a teammate had pushed something from elsewhere, it could be overwritten, and because no commit ever really happened there was no diff to look at afterwards. Pushing now runs actual git: it clones your repository, applies your project on top, and makes a normal commit with a normal diff, signed in with the GitHub account you already connected.

  • Your history is preserved and each push is a normal incremental commit, not a replacement.
  • Files that exist only in the repository are left alone rather than deleted.
  • PiPilot now shows you exactly which files changed on the remote — and can tell when a change it intended never actually made it.
  • The commit id you are shown is read back from git after the push, so it is always the real one.
Learn more in the docs
v5.6
Fix

Builds no longer fail with “All models failed”

If a build ever stopped with a wall of red text beginning "All models failed", this was why. The list of backup AI models the builder falls back to had quietly rotted: in one path it had been emptied on the assumption our provider's own router would cover it, and in the other every single backup model had been withdrawn or moved behind payment by its provider. So when the primary model was busy, there was nothing behind it. Both lists have been rebuilt, and every model in them was tested against a real request before it went in.

  • Six working models now sit behind the primary one, spread across five independent providers — these rate limits are shared pools, so variety is what actually helps.
  • The image-handling chain went from two models to five, each verified against a real image rather than trusted from a capability list.
  • Error messages were rewritten. Instead of raw provider JSON naming a model you never chose, you now get what happened and what to do next.
  • Fixed a quieter fault where one provider reports failure inside a successful response, which could make the agent appear to run and then do nothing at all.
  • These failures are now recorded on our side. They were not before, which is why this was found from a user report rather than from monitoring.
Learn more in the docs
v5.6
Announcement

Clearer plan limits, and deploys to your own host move to Pilot

We have made the free plan honest about its own ceiling, and moved two things behind a paid plan. Cadet said "unlimited in-browser AI building" while the server allowed 13 prompts a day, and listed a feature that was never actually available on it. That was our mistake and it is now corrected on the pricing page. The limits themselves have not changed. What HAS changed: deploying to your own Vercel, Netlify or Cloudflare account, and pushing to your own GitHub repo, now need Pilot. Publishing a real, live, shareable link is still free and keyless on Cadet, and so is everything else you use to build.

  • Cadet now states its real limits on the pricing page: 13 AI prompts a day (3 premium + 10 standard), 2 Cloud Hours a month, public projects, and a model pool shared with every other free account.
  • Removed two false claims we were making: "unlimited in-browser AI building", and Agent Teams being listed under Pilot when it has always required Squadron.
  • Deploying to your own host and pushing to your own GitHub repo now require Pilot or above.
  • Still free on Cadet: unlimited projects, the full builder, live preview, PiPilot DB, and one-click instant publishing to a real live link.
Learn more in the docs
v5.5
Feature

A community, a public roadmap, and a report button where you actually need it

PiPilot has a community at pipilot.dev/community. Report a bug, ask for a feature, share a prompt that worked, or show what you shipped. Requests are ranked by votes and move across a public roadmap, and when one ships the thread says which release it landed in — so asking for something now has somewhere to go and something to follow. There is also a help button in the builder, next to the model and mode control, that files a report without you leaving what you were doing.

  • The community is live at /community. Bug Reports, Feature Requests and Feedback come first, then Help, Show & Tell, Prompts & Recipes, Templates and the Lounge. Reading needs no account; posting signs you in.
  • A public roadmap at /community/roadmap. Every card began as someone's request. Vote to push one up, and when it ships the card links to the release that shipped it.
  • A help button in the builder composer, beside the model and mode control. Report a bug, request a feature or send feedback in place — it becomes a real thread you can follow, not a message into a void.
  • A report filed from the builder brings its own context: framework, model tier, build mode and project. Most bug reports stall on a missing detail, and asking for it days later rarely works.
  • Share a prompt in a ```prompt block and anyone reading gets an Open in PiPilot button that hands it straight to the builder, ready to run.
  • Paste a published app URL into a post and the thread embeds the running app, not a screenshot of it.
  • Follow a thread and you are told when someone replies or the status changes — a bug moving to Fixed, or a request moving to Shipped.
  • Ask a question in Help and mark the reply that solved it. Answering questions is what builds reputation here, not posting volume.
Learn more in the docs
v5.4
Fix

Every connected account now works the same way: the credential stays on our side

A follow-through on the connection fixes earlier today. The parts of PiPilot that still handed a token to the page — deploying to Vercel, Netlify and Cloudflare, cloning and pushing repositories, running commands in a cloud sandbox, launching a mission, configuring a database, and Stripe and Supabase management calls — now resolve that credential on our servers from the account you connected. The app keeps only whether a provider is connected, never the key itself. Alongside the practical benefit: the agent always uses the freshly refreshed token instead of whatever copy the page happened to be holding.

  • Deploys no longer carry your token. Publishing to Vercel, Netlify, Cloudflare or GitHub sends only the build; the credential is attached on our side from the account you connected.
  • Cloning and pushing repositories works without the page ever holding a GitHub token — including the real git running inside a cloud sandbox, and the pull requests a mission opens for you.
  • Commands you or the agent run in a cloud sandbox get their provider logins injected at the server, so the command line tools stay signed in without your keys making the round trip.
  • Database configuration — enabling the REST Data API, checking its status, refreshing its schema — now authenticates server-side with the key on your connection instead of reading it out of the page.
  • Re-checking a connection is a server-side check now. PiPilot can tell you a GitHub connection has lost repository access, or that a provider revoked a grant, without the browser needing the credential to ask.
  • Nothing to do on your side: existing connections keep working, and none of this changes how you connect an account.
Learn more in the docs
v5.3
Fix

Connections that stay connected — and credentials that never touch your browser

Two problems, one fix. Connected accounts used to expire quietly after about an hour, and the next thing the agent did with them failed in a way that looked like a broken integration rather than a lapsed sign-in — they now refresh themselves, on demand and on a schedule, so they keep working while you are away. And the credentials themselves have moved out of the browser entirely: they are held server-side and attached to each request there, instead of being stored in the page and sent along with every command.

  • Provider credentials no longer live in your browser. Your Vercel, GitHub, Supabase and Stripe tokens are held server-side and attached to requests there, so they are never stored in the page or sent along with each command.
  • Connections renew themselves. Sign-ins used to quietly expire after about an hour, and the next thing the agent tried would fail with an authorization error that looked like a broken integration. They are now refreshed before they run out.
  • They stay live while you are away, too — a scheduled job running overnight, or a project you come back to after a day, now finds working connections instead of expired ones.
  • Pushing to GitHub no longer hands your token to the page. A GitHub token can write to every repository you own, so it is now supplied at the moment of the push and never exposed to the browser.
  • Fixed: a Supabase account connected by sign-in was never usable by the agent at all — the token was stored under a name nothing read. Existing connections are repaired automatically; no need to reconnect.
Learn more in the docs
v5.2
Feature

Connect your stack in one click — no more pasting tokens

Connecting Vercel, GitHub, Supabase or Netlify used to mean leaving PiPilot, creating a token with the right scopes, and pasting it back. Now you click Connect, approve it, and you are done. For the providers that cannot do that, the credential you paste is checked the moment you paste it — so a wrong token fails on the spot, in plain language, instead of surfacing as a confusing deploy error twenty minutes later.

  • One-click sign-in for Vercel, GitHub, Supabase and Netlify — approve in a popup and come back connected. No token, no scopes to get right.
  • Every pasted credential is now verified before it is trusted: GitHub tokens missing repo access, Vercel tokens that cannot see the team you typed, and Resend keys whose sending domain is not verified are all caught immediately.
  • Cloudflare reads your Account ID straight from the token, so there is nothing to hunt for on a second dashboard page — and a token that cannot reach an account says so instead of failing at deploy time.
  • MCP servers can be connected by signing in too. PiPilot discovers the server, registers itself, and runs the approval — so any compliant server works without configuration.
  • MCP traffic moved onto its own edge network, making tool calls noticeably quicker.
Learn more in the docs
v5.1
Announcement

A live status page at system.pipilot.dev

Every part of PiPilot — the builder, the agent runtime, previews, BaaS, hosting, video, billing and more — now reports its own health on a public page, backed by automated probes that run continuously rather than by anyone remembering to update it. When something breaks you can see what, since when, and what we are doing about it, without asking.

  • 29 tracked components across 6 groups, each with 90 days of uptime history at a glance.
  • Automated smoke tests probe every service on a schedule and record the result — the page reflects what the system actually does, not what we think it does.
  • An incident calendar with the full timeline of each event: when it started, every update, and how it was resolved.
  • A live status indicator in the site footer, so you can see at a glance whether anything is wrong.
Learn more in the docs
v5.1
Feature

Custom domains, and buying one without leaving PiPilot

Point a domain you already own at an app you built, or buy a new one right in the flow — with DNS configured automatically and TLS issued for you. No registrar dashboard, no copying nameservers between tabs, no waiting to find out whether you got the records right.

  • Connect a domain you own: PiPilot writes the DNS records and provisions the certificate, then verifies it end to end before telling you it worked.
  • Buy a domain in-app — search, pick, pay once, and it is attached to your project automatically. Auto-renew stays off unless you turn it on.
  • Verification fails closed: a domain is only reported as live once it genuinely resolves and serves over HTTPS.
Learn more in the docs
v5.0
Announcement

Crew — a chat-first workspace for everything that is not a website

Mobile apps, CLIs, npm packages, slide decks and design work no longer pretend to be websites with a preview pane. Crew is a workspace built for them: you talk to Pilot, which writes the code directly, while Crew independently verifies the result in a real sandbox and reports back. What you see is what actually ran, not a hopeful summary.

  • Pilot writes the code and Crew verifies it in a real cloud sandbox — the verdict comes from the run, not from the model asserting success.
  • Mobile projects build and preview properly, with platform-aware guidance so React Native never gets handed CSS that cannot work.
  • A sandbox console you can actually read, so "why did the preview not start" has an answer instead of a spinner.
  • Previews serve only from the sandbox and refresh when you switch back to them — no more stale screens or dead links from a previous run.
  • Sessions resume across dispatches rather than restarting cold, so context carries between turns.
Learn more in the docs
v4.9
Feature

Faster, cheaper inference — and it shows up as speed

The model layer behind the builder moved onto edge infrastructure and gained a faster primary provider with automatic fallback. The practical effect is that the agent starts sooner and stalls less, and outages in any single provider stop being your problem.

  • A faster inference path with automatic failover — if one provider degrades, the chain moves on without you noticing.
  • Missions and Crew route through the same edge network, so background work is no slower than foreground work.
  • Smarter context handling keeps long sessions coherent instead of forgetting the start of the project by the end of it.
Learn more in the docs
v4.9
Feature

Previews that survive being left alone

Cloud previews used to expire quietly, leaving a dead link and no explanation. Now a preview tells you when it has gone to sleep and brings itself back with one click — and the ones that can run in your browser still do, instantly and free.

  • An expired preview says so and offers a Revive button, instead of failing to connect with no reason given.
  • Previews stay warm while you are working and shut down when you are not, so nothing is burned idling.
  • Projects that need a real toolchain get a real cloud sandbox; everything else keeps running in your browser at no cost.
Learn more in the docs
v4.9
Feature

Podcasts, a public video gallery, and clearer video limits

The media side grew up. Generate a multi-voice audio podcast from a prompt, publish finished videos to a public gallery where people can watch and vote, and see exactly what your plan allows before you start rather than after a render fails.

  • Multi-voice podcast generation — distinct voices per speaker over ducked background music, exported as a finished audio file.
  • A public Video Hub: publish what you make, and browse, upvote and comment on what others have made.
  • Per-plan length caps and a daily quota shown up front — and edits to an existing video never count against it.
  • Assets you supply are used exactly as given; the engine no longer substitutes stock footage for something you chose deliberately.
Learn more in the docs
v4.9
Announcement

PiPilot BaaS is open to everyone

The managed backend is out of preview. Databases, authentication, storage, realtime, cron and serverless functions are available on every plan, with the data layer running on edge infrastructure and a contract test suite that verifies its behaviour continuously rather than on release day.

  • Generally available with full documentation — provisioning, access policies, storage, functions and the client SDKs.
  • Access policies are verified by an automated contract suite that runs continuously, so a policy that should deny cannot silently start allowing.
  • Built-in AI, team invites and web push — the pieces most apps need next, without another vendor to integrate.
  • The data plane runs at the edge, close to your users.
Learn more in the docs
v4.9
Feature

Billing, plans and organisations

Plans are now self-serve. Pick one, pay, and your limits update immediately — including metered cloud time for the heavier workloads. Teams get shared workspaces with pooled capacity, and referrals reward you when someone you brought subscribes.

  • Four self-serve plans with metered cloud time for sandbox-heavy work; upgrades and downgrades take effect immediately.
  • Organisation workspaces with pooled per-seat capacity, so a team shares one balance instead of competing for it.
  • Referrals that pay out when the person you referred actually subscribes.
  • Subscription state reconciles itself hourly, so a missed webhook cannot leave you on the wrong plan.
Learn more in the docs
v4.9
Feature

Missions — work that keeps going after you close the tab

Hand the agent a job and leave. Missions run on their own in the cloud, on a schedule if you want, and report back when they are done — for the work that is too long or too repetitive to sit and watch.

  • Long-running agent jobs that survive closing the browser, with a full transcript waiting when you return.
  • Schedule them to repeat — daily checks, recurring maintenance, anything you would otherwise forget.
  • Scheduled runs get the provider access they need automatically, so a mission at 3am is not blocked on a login.
Learn more in the docs
v4.9
Feature

Import an existing codebase, and a launch wizard for new ones

PiPilot no longer has to start from nothing. Bring in a repository from GitHub or GitLab, a local folder, or a zip, and work on it with the full agent. Starting fresh instead? The launch wizard turns a one-line idea into a planned, named, branded project before the first prompt.

  • Import from GitHub, GitLab, a folder or a .zip — the agent picks up an existing project as if it had built it.
  • A launch wizard that plans the build, generates the branding, and sets the project up before you write a prompt.
  • Per-framework rules keep generated code idiomatic for the stack you are actually on.
  • Real version control throughout, with push and pull to your own remote.
Learn more in the docs
v4.8
Announcement

PiPilot BaaS — a full backend for any app, from one SDK

Give any frontend — React, Next, Vue, Svelte, Expo, on your own host — a complete managed backend without leaving the browser. PiPilot BaaS provisions a database, user authentication, file storage, realtime channels, scheduled cron jobs, and serverless functions, all reached through the @pipilot/client and @pipilot/server npm SDKs. The agent sets it up autonomously: provision, set access policies, seed data, deploy functions, and wire it into your app.

  • A managed database with per-table access policies — the agent creates tables, sets policies, and seeds data for you; browse and edit rows in the Backends console.
  • Built-in user auth: email + password, passwordless magic links, and Google/Apple/X sign-in — every backend auto-provisions a user directory.
  • Serverless FUNCTIONS — deploy real backend routes (Stripe checkout + webhooks, privileged logic) with the in-container db, storage, and secrets in scope.
  • Realtime broadcast channels and scheduled CRON jobs, plus managed secrets and keyless AI — the full backend surface, with no servers to run.
  • Consumed from any app via @pipilot/client (browser) and @pipilot/server (service) — install, createClient, and go. Your app stays on its own stack and host.
Learn more in the docs
v4.8
Feature

Real user accounts for the apps you build

The apps PiPilot builds can now sign in real end-users out of the box. Add email-and-password accounts, one-tap passwordless magic links, or Google/Apple/X — with branded verification emails and a per-app user directory — in a few lines of the @pipilot/client SDK. Sessions are issued and verified server-side, so per-user data policies just work.

  • Email + password sign-up with branded, no-reply verification emails, plus passwordless magic-link sign-in.
  • Google, Apple, and X (Twitter) sign-in with zero OAuth config — one centralized broker handles it for every app.
  • Every sign-in records the user into a per-app directory, so your app can scope and manage its own users.
  • Secure sessions verified server-side; owner/authed table policies enforce per-user data access automatically.
Learn more in the docs
v4.7
Announcement

PiPilot Host Fullstack — now a first-class project type

PiPilot Host is now something you pick, not just something you ask for. Choose “PiPilot Host Fullstack” in the composer and you start on a working scaffold wired to the platform SDK. The AI edits real files like any project; one Publish packages the whole app — frontend, backend, and images — and ships it, self-healing on validation errors. No deploy config, no slug, no separate account.

  • New “PiPilot Host Fullstack” project type in the composer and New-project picker — start on a preconfigured full-stack scaffold in one click.
  • The agent builds by editing real files (frontend + backend on the platform SDK); a local preview renders the UI instantly while you work.
  • One Publish packages the entire project — text and binary assets — and deploys it; the platform assigns the address, runs QA, and the agent fixes validation errors automatically.
  • A dedicated Publish panel: SEO meta baked into the page, plus connect a custom domain with automatic TLS.
Learn more in the docs
v4.6
Announcement

Introducing PiPilot Host — full-stack hosting, a Vercel alternative

Our proprietary hosting engine is here. Ask PiPilot to deploy and it ships a live frontend AND a serverless backend — with a database, object storage, and managed secrets — all on one domain, with zero config and no separate account. The agent writes the backend, provisions the data plane, deploys, and polls until it’s live, fixing build errors on its own.

  • PiPilot Host: a full-stack deploy target where frontend + serverless backend ship together on the same domain — no separate API host, no CORS setup.
  • Every hosted app gets a production database and object storage with a typed SDK from the first deploy — no provisioning, no connection strings.
  • Managed secrets via one-time user-entry links (values never touch the browser or the model) and a tamper-verified data plane that rejects writes if the backend code is altered.
  • Versioned deploys with instant rollback, custom domains with automatic TLS, and per-user isolation enforced server-side.
  • Driven entirely by the agent — new deploy_hosted_app + hosted_app tools mean you just describe the app and it goes live. Prefer your own host? PiPilot still deploys to Vercel, Netlify, Cloudflare & GitHub Pages.
Learn more in the docs
v4.5
Feature

AI Video Generation — from a prompt to a finished MP4

Ask PiPilot for a promo, teaser, or product demo and it renders a real, narrated video in the cloud — themed motion cards, custom or stock imagery, background music, AI voiceover, captions, and even a live screen-recorded walkthrough of the app you just built. Every render is published to your Google Drive as a shareable link.

  • New video capability: describe a storyboard and PiPilot renders a 1080p MP4 — themed title cards, Ken Burns imagery, 35 transitions, and an auto-generated thumbnail.
  • Screencast scenes drive your DEPLOYED app live (with a synthetic cursor + click ripples) to record a genuine product demo — sign in, click through features, all scripted.
  • Scene visuals are generated to your prompt (accurate and on-brand) or pulled from a huge built-in stock library; live video b-roll via Pixabay when connected.
  • Built-in AI voiceover with 20+ voices, background music that auto-ducks under narration, and burn-in captions — title cards and captions can even type on-screen.
  • Finished videos publish to your Google Drive as a durable, shareable URL. Free plan renders up to 3 minutes with a small watermark.
Learn more in the docs
v4.5
Fix

Polish: media previews and richer link cards

A few quality-of-life upgrades around media and sharing: the File Manager now plays video and audio inline, and links to PiPilot now unfurl with a proper branded preview card.

  • File Manager previews video and audio files inline with a native player, alongside images.
  • Video captions and typewriter text overlays render smoothly, and title-card typing is now snappy instead of lagging.
  • Sharing a pipilot.dev link now shows a branded 1200×630 preview card on social and chat apps.
Learn more in the docs
v4.3
Feature

The Launchpad: a weekly competition for what you ship

A Product-Hunt-style stage for apps built with PiPilot. Submit your own published app or nominate someone else’s, gather upvotes and comments, and watch the leaderboard move in real time — every week the top 3 win bonus build hours and a spot on the Wall of Fame.

  • New /showcase Launchpad, also in the /app sidebar — a weekly, Product-Hunt-style competition for published PiPilot apps.
  • Submit your own app or nominate anyone’s published app; every entry gets a shareable link.
  • Signed-in visitors upvote, downvote, and comment — ranking updates live off net score.
  • Top 3 each week win bonus build hours (1st +20h, 2nd +10h, 3rd +5h) and a Wall-of-Fame spot; a new week opens the moment voting closes.
  • A live activity feed and an "All apps" browse tab keep the whole Launchpad discoverable, not just the leaderboard.
Learn more in the docs
v4.3
Feature

Sharper prompts, real brand logos

Small polish across the board: an ✨ enhance button rewrites a rough prompt before you send it, and the MCP marketplace and "Connect your stack" integrations now show real, recognizable brand marks instead of generic icons.

  • ✨ New enhance-prompt button rewrites a rough idea into a clearer, more buildable prompt before you send it.
  • Real brand logos (via Simple Icons) now render across the MCP marketplace and the "Connect your stack" integrations list.
Learn more in the docs
v4.2
Fix

Reliability pass: previews, publishing, and connecting

A cluster of small fixes that add up: File Manager thumbnails always load, republished sites never flash blank, and reconnecting GitHub no longer collides with an old token label.

  • File Manager thumbnails and previews now load reliably via an authenticated fetch.
  • Fixed a brief blank-screen flash right after republishing a site — stale HTML always resolves its bundle now.
  • GitHub token links use a unique, timestamped description instead of a bare label that could collide on reconnect.
Learn more in the docs
v4.2
Feature

One-click GitHub connect, instant hosting

Two friction points, gone. Connecting GitHub now hands you a pre-filled token with exactly the right scopes, and shipping a static site to the web is a single click away.

  • Connecting GitHub opens a pre-filled token page with exactly the scopes PiPilot needs and no expiration.
  • Publish a static site to a free *.pipilot.dev address in one click.
  • No config, no CLI — the connector and the publish button do the whole job.
Learn more in the docs
v4.2
Feature

A template gallery for every framework

Skip the blank page. Start from a ready-to-use template in any web framework, or publish one of your own for the community — right from an in-app gallery or the public template gallery.

  • 6+ starter templates per web framework, plus blank scaffolds — pick one in-app or on the public /templates page.
  • Publish your own project as a template; a Community tab surfaces what other builders have shared.
  • ✨ AI-written descriptions summarize a new template the moment it is published.
Learn more in the docs
v4.2
Feature

Your Profile: sharing, referrals, and account at a glance

A real home for your account. See your plan and usage, share a project with any PiPilot user by email, and track the friends you have invited — all from one Profile view.

  • New Profile view: edit your display name, see plan + build-hour usage, and manage connected accounts.
  • Share a project with any PiPilot user by email — they claim their own copy in one click.
  • Invite friends and earn bonus build hours when they subscribe, with a clear welcome for anyone who joins from an invite.
Learn more in the docs
v4.2
Feature

File Manager, rebuilt

Your project files finally get a real file manager. Organize with folders, drag files in, select and download a batch as a ZIP, and actually see what you are looking at.

  • Create, rename, and delete folders with full breadcrumb navigation.
  • Drag-and-drop upload, multi-select, and one-click ZIP download for any set of files.
  • Search, sort, and browse a grid view with real image thumbnails and previews.
Learn more in the docs
v4.2
Feature

Bring your own assets to a build

Hand the agent your own logo, image, or document and it uses it — for real, not just as a reference. Generated images also got sharper: no more garbled text baked into logos and banners.

  • Attach images and docs right in chat — the agent reads them as part of the build.
  • New save_asset tool imports an uploaded image or logo straight into the project as a real, usable file.
  • Generated images no longer bake in garbled text — logos become symbolic marks, OG images stay textless, and every request uses a valid aspect ratio.
Learn more in the docs
v4.2
Feature

Clone any UI

Point the agent at any public website and it studies the real thing: design tokens, components, fonts, and layout, then rebuilds it in your project.

  • Give the agent a URL and it extracts design tokens, components, fonts, and assets from the live page.
  • A responsive pass and a screenshot confirm what was captured before anything gets rebuilt.
  • The agent rebuilds the design in your project — a real starting point, not a rough guess.
Learn more in the docs
v4.2
Feature

DeepWiki: ask about any GitHub repo, built in

The agent now has DeepWiki wired in as an always-on tool. It can read the docs and structure of any public repository on GitHub and ask questions about it — so it builds against how a library actually works, not a guess.

  • Built-in DeepWiki MCP — the agent reads any GitHub repo’s wiki, structure, and docs on demand.
  • Ask a question about a library or codebase and get a grounded answer mid-build.
  • Free, no token, always on — nothing to connect or configure.
Learn more in the docs
v4.2
Announcement

AnyClaude SDK — our open-source agent engine, now core

The engine that runs every PiPilot build is now the open-source AnyClaude SDK, published on npm and adopted as the core builder in the PiPilot workspace. A more capable agent loop with context-editing and background sub-agent dispatch — and one you can build on yourself.

  • AnyClaude SDK is open source on npm (anyclaude-sdk) and now powers PiPilot’s agent loop.
  • A sturdier build engine: context-editing, deferred tool loading, and background team dispatch.
  • The same SDK we build on is available to the community to build their own agents.
Learn more in the docs
v4.2
Feature

PiPilot DB — a Postgres database, auto-provisioned

Every app can now get a real Postgres database with zero setup. The agent provisions PiPilot DB automatically as it builds — no keys, no dashboard — and you can claim it into your own account to keep it forever.

  • Production-grade Postgres provisioned in seconds — no signup, no connection strings.
  • The agent creates tables and runs SQL for you, with Auth and a REST Data API included.
  • Claimable and portable: claim it into your own account with no migration and no lock-in.
Learn more in the docs
v4.1
Feature

Mobile builds & app-store submit

PiPilot now ships native mobile apps end to end. The agent builds an Android APK or an iOS app through Expo (EAS), previews it live on your phone with Expo Go, and submits straight to Google Play and the App Store using your own connected store accounts.

  • Build Android APKs and iOS apps via Expo (EAS) — no Mac or local toolchain required.
  • Submit to Google Play and the App Store with your connected Apple Developer and Play accounts.
  • Preview a running build on a real device instantly through Expo Go.
Learn more in the docs
v4.1
Feature

Desktop apps with cloud builds

Ship cross-platform desktop apps from the same chat. The agent scaffolds Tauri or Electron projects and runs a GitHub Actions matrix that builds for macOS, Windows, and Linux in parallel — then delivers the signed installers to your Google Drive.

  • Generate Tauri and Electron desktop apps from a single prompt.
  • GitHub Actions matrix builds macOS, Windows, and Linux artifacts together.
  • Finished installers are delivered straight to your Google Drive.
Learn more in the docs
v4.1
Feature

Mission Runners

Hand off long jobs to background autonomous cloud agents. Spawn a Mission Runner on your current project or a cloned repo, watch it work, and steer it with follow-up instructions — runners queue up and report back when each mission is done.

  • Spawn autonomous cloud agents that run missions in the background.
  • Monitor progress live, then edit-and-resend to refine a mission mid-flight.
  • Queue multiple missions across your project or any cloned repository.
Learn more in the docs
v4.1
Feature

The fullstack hub

PiPilot is no longer just for web apps. Describe what you want and the agent builds it — web frontends, backend APIs, Python/FastAPI services, CLIs, npm packages and SDKs, mobile, and desktop — with kind-aware previews that run each project type the right way.

  • Build web apps, backend APIs, Python/FastAPI services, CLIs, npm packages/SDKs, mobile, and desktop.
  • Kind-aware previews launch each project type in the way that fits it.
  • Publish-ready npm packages and SDKs scaffolded straight from a prompt.
Learn more in the docs
v4.1
Feature

Connect your stack — deploy to your own accounts

New connectors put you in full control. Connect Vercel, Netlify, Cloudflare Pages, Expo (EAS), Apple Developer, Google Play, GitHub, Supabase, PiPilot DB, Stripe, or Resend once, and the agent deploys, submits, and wires up everything in your accounts — your URL, your data, and your billing stay yours.

  • New Expo (EAS), Apple Developer, and Google Play connectors for native build and submit.
  • Deploy to your own Vercel, Netlify, or Cloudflare Pages accounts in one step.
  • Full control: your accounts, your URL, your data, your billing — nothing locked in.
Learn more in the docs
v4.1
Feature

Git version control, built in

Every project now has real version control. The agent can commit, check status, read the log, restore files, and push or pull to your remotes — so your build history is durable and entirely yours.

  • Real git inside the builder — commit, status, log, and restore as the agent works.
  • Push and pull to your own remotes to keep history in sync everywhere.
  • A durable, owned commit history backs every change the agent makes.
Learn more in the docs
v4.0
Announcement

A brand-new V4 — landing, docs, and design system

We rebuilt the entire surface of PiPilot around a calm, editorial design language: a warm off-white canvas, expressive display type, and components that get out of your way. The new landing, docs, and showcase all ship together.

  • A cohesive design system shared across every marketing and product page.
  • Rewritten docs with quickstarts, guides, and copy-paste recipes.
  • A community Showcase featuring real apps shipped from the browser.
Learn more in the docs
v4.0
Feature

Build from anywhere

The headline of V4: full cloud building from any device. Spin up an E2B sandbox, build a complete app from your phone, and watch it come to life in a live preview that runs entirely in the cloud — no laptop required.

  • Mobile cloud building via E2B sandboxes — ship a full app from your phone.
  • Live preview runs in a cloud sandbox, so what you see is exactly what deploys.
  • Sandboxes boot in seconds and stay in sync with every edit the agent makes.
Learn more in the docs
v4.0
Feature

Agent teams

Big builds no longer wait on a single agent. Spawn a team of background agents that split the work, coordinate among themselves, and report back — so a multi-screen app comes together in parallel instead of step by step.

  • Spawn background agents that collaborate and self-coordinate on large builds.
  • Agents divide work by feature and merge results without stepping on each other.
  • Watch progress stream live as each agent checks off its part of the plan.
Learn more in the docs
v4.0
Feature

Real browser automation

The agent can now drive a real cloud Chromium through Playwright. It opens any URL, clicks through flows, screenshots the result, and verifies its own work — so the app it builds is the app it actually tested.

  • The agent drives a real cloud Chromium (Playwright) to test and navigate any URL.
  • Automated screenshots let the agent see and self-correct visual bugs.
  • End-to-end flows are exercised before a build is handed back to you.
Learn more in the docs
v4.0
Feature

Instant deploy, zero setup

One click takes your project from prompt to a live URL — a free, keyless instant deploy with no account, no provisioning, and no bill to set up. Add PiPilot DB for data, or ship to your own Vercel/Netlify/Cloudflare for a full backend.

  • One-click instant deploy: free, keyless, a live shareable link in seconds.
  • Static frontend hosting — pair with PiPilot DB (instant Postgres) when you need data.
  • Your deployed app gets a shareable URL the moment it ships.
Learn more in the docs
v4.0
Feature

130+ MCP integrations

Connect the tools you already use. PiPilot now speaks MCP to more than 130 services, so the agent can read your repos, charge a card, query a database, or post to a channel as part of building your app.

  • Connect GitHub, Stripe, Supabase, Slack, Figma, and 125+ more via MCP.
  • Integrations are usable mid-build — the agent calls them as it works.
  • Each connection is scoped and authorized through your own account.
Learn more in the docs
v4.0
Feature

Your data, your Drive

Projects now sync to a private folder in your own Google Drive. It costs nothing, it works across every device, and you stay in full control of your files — we never hold your work hostage.

  • Projects sync to a private folder in your own Google Drive — zero cost.
  • Cross-device by default: start on your phone, pick up on your laptop.
  • Your files live in your Drive, fully under your ownership and control.
Learn more in the docs
v4.0
Announcement

Secure accounts

V4 introduces real accounts. Sign in with Google, GitHub, or email, and the AI API is now gated behind your identity — so usage is yours, your projects are yours, and everything is tied to a login you trust.

  • Sign in with Google, GitHub, or email.
  • The AI API is now gated behind your account for secure, attributable usage.
  • Sessions persist across devices and surfaces, including mobile.
Learn more in the docs
Stay in the loop

Want updates? Start building.

New releases land every week. Jump in now, or leave your email and we’ll send the highlights straight to your inbox.