What’s new in Playcode

Gemini 4 Argon - Google's new frontier model, built for deep, long-horizon work - is now available on the Standard tier, next to Claude Opus 5.5. Google released it yesterday; it went through our full verification before reaching the picker: live tool-calling, prompt caching, and token accounting all confirmed on the real wire.

Argon arrives at Google's introductory pricing, which runs through November 30: until then it is one of the cheapest ways to run a frontier model on Playcode. If you want long multi-step builds, large refactors or research-heavy work at well under flagship spend, this is the moment to try it.

GLM 5.3 Flash is now in the model picker. It is one of the cheapest models we offer, with reasoning quality close to models many times its price, a 1M-token context window, and image understanding. It thinks before every answer, so it is thorough rather than instant - pick it for budget builds where a little patience is fine.

Your apps and your tools can now talk to Playcode directly - three releases in one day:

• @playcode/sdk 0.3 (npm) - the official SDK for your app's backend. Zero dependencies, fully typed, works in any Node or edge runtime. Send email, call every management operation, and - new today - generate images: pc.media.image({ prompt }) returns a finished image hosted on Playcode, paid per image from your workspace credits. Video generation (pc.media.video()) rides the same way.
• @playcode/cli (npm) - npm i -g @playcode/cli, then playcode login signs in through your browser. List projects, read and run things on a project's computer, publish, and reach every management operation as playcode <family> <operation> - new operations appear in the CLI the moment they exist, no update needed.
• An MCP server for your coding agent. playcode mcp runs a local MCP server over your own sign-in, built for Claude Code, Cursor, and Claude Desktop: your agent discovers Playcode operations by searching, reads the exact argument shapes, and executes - with everything scoped to the permissions you granted at sign-in.

New projects created from today's template get the SDK preinstalled. This is the start of the platform surface - more capabilities land on the same three doors.

Claude Sonnet 5.5 - Anthropic's newest Sonnet, "the best combination of speed and intelligence" - is now on the Quality chip in the model picker, at the same price as Claude Sonnet 5. Sonnet 5 is superseded; if you had it pinned, your pin keeps working.

Your server can now hear Playcode. In Workspace settings, Developers gained Webhooks: add an endpoint and we POST every matching event to it - a domain changed, a publish started, mail delivered or bounced. Every delivery is signed with a secret we show you once; verify it, and replay protection comes from the delivery id. Failures retry on their own for about three days, and Send again runs one now. Filter by type, like domain.*, or take everything.

Beside it, Activity: every write in the workspace, the moment it happens - who did it, through which door (the app, the CLI, the API, an assistant), and what it touched. It is the audit answer for a token or a tool you let act as you.

The same ledger is on the API as eventSearch, so a script can follow your workspace with a cursor instead of polling each resource.

Your workspace credits are now one balance for everything Playcode runs for you. Until today only the AI chat and agents drew credits.

• Cloud computers use credits while they are awake, for the disk they

keep, and for traffic beyond the included amount. A sleeping computer bills disk only. Each computer's rate is shown next to its hours in Settings > Usage.

• AI in your apps - requests your apps make through the AI Gateway with

their secret key - use credits too, at the model's rate.

• Email beyond your plan's included sends keeps its per-email price.

Settings > Usage now shows all spending in one place: AI chat + agents, one row per project whose apps used the AI Gateway, Email, and one row per cloud computer, each with quantity × rate = credits. The period buttons at the top drive the whole page - today, this week, this month, all time - and the spending list names the period beside its total. Email alone is shown per billing cycle, because its included sends are a cycle allowance.

If your credits run out, AI requests pause until you add credits. Email beyond your plan's included sends is stored but not delivered until you do; included sends and mail to your own team always go out. Cloud computers keep running: we email you, and only if the balance is still empty 72 hours later do they pause. Nothing is deleted, and the same computers start again as soon as credits are added.

Nothing changes about how you buy credits, and your balance shows the same number in the editor, in Billing and in Usage.

Mobile projects get a Phone tab beside Preview (View, then Phone; on the phone it is in the project menu). It shows your app the way a phone sees it, a QR code to scan with your phone's camera, and one line that says whether the phone preview is running. The QR opens the app in your phone's browser: nothing to install, no account. A Browser | Expo Go switch turns it into the native preview for Expo Go when you want that; Expo now asks for the same Expo account on the phone and on the dev machine, and the chat walks you through it. When you are already on the phone, the tab has an Open on this phone button, and the address in a chat card is a link you can tap.

Your dev machine now has its own address. Anyone you give it to can use the app while the machine is on: your phone, a teammate, a client on a call, a webhook you are testing. The machine stays awake while the app is in use from any device.

Only you can turn it on: opening the project in Playcode wakes it, and so does the agent while it works for you. It goes to sleep after a quiet while, and after four hours without you or the agent. When the app on your phone finds the machine asleep, it shows a banner with one button that opens the project and wakes it.

The address is not a public link. Publishing still is: a published app keeps its permanent link that works for everyone, whether your dev machine is awake or not.

Your Profile settings now list every browser you are signed in on - the browser and system, when it signed in, when it was last seen - with Sign out on each row and Sign out everywhere else in one click. Signing out really ends that session on our side, so a lost laptop stays out.

Sensitive actions - buying a domain, changing your sign-in email, creating or revoking a token - now ask you to confirm it's you with the sign-in code when it has been a while since you last did. Everyday work never asks.

In Workspace settings, Developers gained a Signed in as you list: the tools you let act as you through Sign in with Playcode, the workspace each one may act in, what it may do, and Revoke to sign a tool out on every computer at once. The project's Secret key pane replaces API keys: the key your app already has, masked, copied on purpose, rotated when it leaks.

Giving your site an address you already own used to start with four tabs named after mechanisms. It now starts with the name. Type it, and Playcode looks up where it is managed and recommends the best way first:

• Let Playcode handle everything - we copy your current settings over,

your email keeps working, and you make one small change at your provider. Then never again.

• One setting at your provider - one line to add, and we watch until it

lands.

• Playcode's address at your provider - the plainest setting there is,

for providers that cannot do the one above.

Each card carries a ? that says in one sentence what the setting is. On Cloudflare, the one setting leads and nothing pushes you off it. Moving the whole registration to Playcode is a quiet line under the first card, not a tab.

The setting card shows a live chip - *Not seen yet*, *Found*, *Live* - and turning on Also answer at www adds its one extra setting right there, same visit. The same flow runs for Playcode Cloud and Playcode Pages projects, and the workspace's Domains list now keeps watch on its own while anything is still setting up.

Attach a document to the chat and the agent can work from it - no more re-saving a spreadsheet as CSV so it can be read.

• PDF: the agent sees the document itself - text, tables and layout -

the same way it sees an attached image.

• Excel (.xlsx) and CSV: the agent reads the rows, one sheet or many.

Export a table from your project, edit the prices in Excel or Google Sheets, attach it back, and the agent updates the site from it.

• Word (.docx): headings, paragraphs and tables come through as text.

This works in browser and Cloud projects, and for files you attached before today. Very large PDFs (over 100 pages) are not shown to the agent; it will ask you for the relevant pages instead. Legacy formats (.xls, .doc, .pptx) are not supported yet - save as .xlsx, .docx or .pdf.

GPT-6 Astra - OpenAI's most capable model, built for the hardest end-to-end work - is now available on the Ultra tier, next to Claude Fable 5.1. OpenAI launched it yesterday behind a limited-access program; our access opened this morning and it went through our full verification the same hour: live tool-calling, prompt caching, and token accounting all confirmed on the real wire before it reached the picker.

Astra is priced identically to Claude Fable 5.1 ($10 / $50 per million tokens at the provider), and because its tokenizer encodes the same work to roughly a third fewer tokens, the same build tends to cost fewer credits. Claude Fable 5.1 remains the Ultra default.

Claude Fable 5.1 is now the default model on the Ultra tier, replacing Claude Fable 5. It is Anthropic's most capable model, tuned for the hardest reasoning and long agent sessions - and it comes with a real cost improvement: reading cached context is 4x cheaper than on Fable 5. In practice that is most of what a long coding session pays for, so the deeper into a project you are, the more you save.

Token prices are unchanged. Claude Fable 5 remains available in the model picker if you have it selected.

Attaching files used to mean hitting a small target inside the chat box. Now the whole editor catches your files:

• Drop anywhere in the chat - the panel lights up while you drag, and

the file attaches to your message.

• Drop an image straight onto your page. Drag it over the preview and

the element under your cursor highlights - release, and the image lands in the composer aimed at that exact spot. Press Enter and the AI places it there.

• Drop on Home to start a new project with the file already attached.
• While you drag, the sidebar shows your project's file tree, so you

can also drop a file straight into a folder.

Every drop answers visibly: the file flies to where it landed, and if you drop somewhere that can't take files, a short note points you to the chat or the file tree. A missed drop never navigates the page away or loses what you typed.

Ask for a mobile app - or add one to a project you already have - and the agent builds it alongside your site and backend, in the same project.

• One project, three surfaces. The mobile app (React Native + Expo)

lives next to your frontend and your NestJS backend and talks to the same API and database. A mobile app that arrives with a real backend, its own data, a domain and email is the whole product, not a demo shell.

• See it in the browser first. The app renders inside the normal

Playcode preview while the agent works, so you watch screens appear without touching your phone.

• Then hold it in your hand. Scan the QR code the assistant prints in

chat and the same app opens on your real phone through Expo Go, live against your project's backend.

Store binaries and app-store submission are a separate, upcoming step - what ships today is building, previewing, and running your app on a real device.

Your project's address no longer requires a detour through a registrar.

• Search, buy, attached. Look up a name, pay with your card, and the

domain is registered to you and connected to your project - DNS records, the www variant, and the certificate handled for you.

• A guided flow that tells the truth. Every step of the purchase shows

its real state - reserved, registered, connecting, live - so you are never left staring at a spinner wondering if your money did anything.

• Your domain stays yours. It is a normal registration in your name;

nothing locks it to us.

Ask for something big - a storefront, an admin panel, order emails - and the agent now breaks it into parts you can follow, instead of leaving you to read a stream of technical steps.

• A plan card in the chat. The parts of your order in your own words,

each one pending, building, or done. On full-stack apps, a part only turns done after the server checks that its page actually loads - and every finished part carries an Open button with the real address, so "the admin panel is ready" is a click, not a path to guess.

• One line while it works. During a build, a quiet line above the

message box shows which part is in progress and for how long - real elapsed time, not a guess.

• The plan opens as its own page. Click it to read the full plan,

nicely rendered with diagrams, without leaving the chat. When the agent updates the plan, you see what changed - changed sections are marked, and a history lets you read any earlier version. Every plan change is a real commit in your project's git history.

• The preview stops playing dead. While the agent rebuilds your app,

the preview keeps the last good page dimmed under one line - "Rebuilding this page - it comes back by itself" - instead of flashing white. A new health check catches blank pages the old green light missed. When nothing is running, real errors still show as errors.

• The agent answers in your language. Switching the app language now

reliably carries into the agent's replies, plan titles, and progress notes.

• Bring your own instructions and skills. A project's AGENTS.md is

now read automatically by every agent working on it - same rules as other AI coding tools, whole file, no silent truncation - and projects can carry their own skills in .agents/skills/, listed and loadable like built-ins.

When your app emails an address that has not confirmed it wants mail yet, that message is Held - stored safely, waiting on a verification. Until today, a held message looked just like normal captured mail, and it was easy to miss that real messages were waiting on you. That is fixed, end to end:

• A new Held status. Held messages show an amber Held chip with the exact reason on the row - clearly separate from mail that is simply captured by design.
• A standing notice in the editor. While anything is held, the panel shows "N messages waiting on you" with a direct door to Settings > Email.
• An email to you. The first time a message is held for an address, the project owner gets an email naming the address - so a contact form filling up overnight can no longer wait silently. Repeats fold into at most one summary a day.
• Deliver held mail in one click. Once the address verifies, Settings shows how many messages were held and a Deliver held button. Nothing ever sends without you.

Two more changes in the same area:

• The Mailbox panel is now called Emails - a clearer name for what it is: every email your app sent, with its delivery status. Playcode Email sends mail; it does not receive it.
• A new help page, What emails can your app send, explains the transactional-only sending policy in plain language.

Browser projects now have Checkpoints - restore points you can save at any moment and return to instantly.

• Save a restore point. Open the project menu and choose **Checkpoint

history, then New checkpoint**. It captures all your files exactly as they are - instantly, without using any credits.

• Name your checkpoints. Rename any checkpoint so "Before the redesign"

is easier to find than a date.

• Restore instantly - and undo it. Restoring puts every file back the way

it was. Playcode saves a safety checkpoint of your current state first, so a restore is never a one-way door. The page does not reload, and your chats stay exactly where they are.

• Publish keeps you covered. Every publish automatically saves a

checkpoint of what went live, so you can always get back to a published state.

You can keep up to 20 checkpoints per project. At the limit, Playcode asks before making room by deleting the oldest one.

Want to explore two directions side by side? Use Duplicate project - the copy gets its own files, chats, and published site.

Email on Playcode Cloud grows up: on paid plans, your app's emails are now really delivered - not just captured in the Mailbox.

• Deliver to verified recipients. Your own address works instantly (you

verified it when you signed up), and your team's addresses too. Add anyone else in Settings > Email - they get a verification link, and once they click it your app can reach their real inbox.

• Honest status on every message. Mailbox messages now show their real

fate: Sending, Delivered, Bounced, or Marked as spam - with the reason, so debugging "the email didn't arrive" takes one glance instead of guesswork.

• New apps send from day one. A fresh full-stack app now emails a

welcome message to its very first registered user - so you see your mail pipeline working before writing a single line of email code.

• Fair pricing. Emails to yourself and your team are always free.

Beyond your plan's monthly allowance, delivery is pay-as-you-go with credits - priced in line with the leading email APIs.

Free projects keep the full capture experience: every email lands in the Mailbox, rendered with working links, ready to test end to end.

Playcode can now build presentations, and it asks one question first: do you want a link you open in the browser and present fullscreen, or a .pptx file you download and edit? They are different things, so it settles that before writing a single slide.

The .pptx is a real one. Actual text boxes you can click and retype, real tables, real speaker notes, charts that carry their own data sheet. It opens in PowerPoint, Keynote and Google Slides, and Cyrillic, Japanese and emoji come out exactly as they went in. This is not a picture of a slide wrapped in a PowerPoint file, which is what most "export to PPTX" buttons hand you.

The more interesting version is a deck generator. Describe the presentation you rebuild every cycle - the monthly client report, the one-pager per prospect, the board update - and Playcode builds you an app that produces it. Your spreadsheet, database or CRM export goes in; finished decks come out, one or two hundred of them, on brand every time because the brand is written into the code. Next month you press the button instead of rebuilding the deck.

A few things worth knowing:

• Generating files needs a full-stack app, since a static site has nowhere to write one. Playcode will offer to set that up.
• Ask for both and you get both from one source: a browser deck to present from, plus a download. Change a slide once and both update.
• Slides use fonts that exist on the machine opening them, so nothing reflows into a substitute when you send the file to a client.

Playcode can now make audio. Ask for it in plain words and you get a file, hosted and ready to use in your project:

• Music - a background bed at an exact length. Ask for eighteen seconds and it ends on the eighteenth second, which is most of why a video reads as finished rather than assembled.
• Sound effects - short one-shots. A click, a coin, a whoosh, a notification.
• Voiceover - narration read aloud, for a walkthrough, a tutorial or an explainer.

It works in any project. A browser game can have its own soundtrack and its own effects without becoming a full-stack app, because the audio is generated on Playcode's side and your project simply receives the finished file.

Everything comes back already levelled to the loudness social platforms and browsers expect, so a clip does not arrive twice as quiet as everything else on the page and need fixing by hand.

Audio uses credits from your balance, priced by what each piece actually costs to make - so a one-second sound effect costs about what a one-second sound effect should, and you are not buying a bundle to get one noise.

Full-stack apps on Playcode Cloud now send email out of the box - no provider signup, no API token, no DNS setup.

• Zero configuration. Password resets, verification emails, order

notifications: your app's email code just works. Playcode provisions the credentials automatically when your app is created.

• The Mailbox panel. Every email your app sends appears in the editor's

new Mailbox panel within seconds - rendered exactly as a recipient would see it, with working links. Trigger a password reset, click the link in the captured email, and complete the flow end to end without leaving Playcode.

• Safe by default. New apps run in capture mode: emails are stored and

shown to you, never delivered to real inboxes - so you can build and test freely. Real delivery to your users is coming next.

• API keys, done properly. The new Settings > API keys page manages

named keys with per-key permissions (send-only or full access), shown once at creation and revocable individually - and Settings > Email shows your sending mode and usage at a glance. A stuck loop that sends the same email over and over is paused automatically; one click resumes it.

"How do I share projects with my team?" is the question we get most, so the Help Center now answers all of it - no support chat required:

• How to share a project - invite people by email

with Viewer, Editor, or Admin roles, manage the Access list, and use the public link. Fully rewritten for the current Share tab.

• Workspaces and teams - the difference

between your Personal workspace and a team workspace, inviting members, and granting access to a whole team at once.

• Roles and permissions - the full

reference: what each role can do in projects and workspaces, how overlapping access combines, and how invitations work.

• Move a project to another workspace -

bring existing projects into your new team workspace. Chats, data, and history travel with them; nothing needs to be recreated.

The Learn about sharing link in the editor's Share tab now lands on the rewritten guide.

Kimi K3, Moonshot's flagship model, is now available in the Choose build quality dialog. It brings a 1M-token context window, always-on reasoning, and vision - so it can hold a very large project in context, think through multi-step changes, and read the screenshots or mockups you attach.

Pick it per chat like any other model, or set it as your account-wide default in Settings -> AI defaults. It is a strong fit for large builds where the whole codebase matters.

Your signed-in home is rebuilt. Instead of a grid of files with a second, weaker prompt box, Home is now the place you build: a short greeting and the exact same composer you use inside the editor. From the very first screen you can attach files, use your voice, and pick your model and effort - no more stripped-down starter prompt.

• One composer everywhere. The box on Home and the box in the editor are the same tool. Whatever you can do in a chat, you can do the moment you arrive.
• Always know where your message goes. A small target chip on the composer shows whether your prompt will start a new project or continue an existing one. If you have a single project, it points there by default; one tap switches it - so a quick change request never spawns an empty project by accident.
• A project sidebar on every screen. Your projects, their chats, and folders now live in one collapsible sidebar. Open any project or jump straight to a past chat in a single click, drag a project into a folder, and reorder folders to taste. It stays put as you move between Home and the editor, so you never lose your place.
• A template gallery when you want it. "Or start from a template" opens a browsable gallery of ready-made site templates, with coding templates - React, Vue, plain JavaScript, and more - one click away. It is opt-in and never gets in the way of just describing what you want.
• A dedicated Archive. Archived projects have their own page with bulk restore, keeping your active project list clean.
• An editor that earns its chrome. A brand-new project opens clean and quiet. Share, Publish, and other controls appear as your project becomes real - once you have actually built something worth sharing - so the toolbar teaches you the workflow instead of overwhelming you on day one.

Old links to your dashboard bring you straight to the new Home, so nothing you had bookmarked breaks.

The template gallery is now fully stocked. Open "Start from a template" and you land in a browsable library of ready-made starting points - more than 50 of them - so you rarely have to begin from a blank screen.

• Site templates for landing pages, portfolios, and other static sites you can publish as-is and then reshape by describing the changes you want.
• Coding starters for full-stack apps - React, Vue, plain JavaScript, and more - including clean Empty starters for when you want the framework without any demo content.
• Ready in every language. The whole gallery is translated, so template names and descriptions read naturally across all of Playcode's supported languages.

Pick one and you are in the editor with a working project in a single click.

The top of the sidebar now holds a workspace switcher. Your personal space and any team workspaces you belong to are one click apart, and the switcher always shows which one you are working in.

Your account controls moved in behind it - profile, plan, and workspace settings now live under the switcher instead of being scattered around the screen. One tidy corner tells you who you are and where you are building, and gets you between workspaces without hunting for a menu.

Cloud projects now have a File Explorer. Open the Files tab in the editor's left panel to browse everything the AI built for you - and edit any file yourself.

• Browse your whole project. Folders load as you expand them, so even huge projects open instantly.
• Edit with a real code editor. Click a file to open it in a tab with syntax highlighting. Changes save automatically to your app.
• Stays in sync with the AI. When the AI finishes making changes, the file tree and your open files refresh on their own.
• Full file management. Create, rename, delete, and download files and folders right from the tree - folders arrive as a single archive.
• Upload from your computer. Drop files or whole folders onto the tree (structure preserved), or use the upload button.
• Markdown preview. Open any .md file and flip between source and a rendered preview.
• Drag to move. Reorganize your project by dragging files and folders in the tree.

Your files live on your app's own server, so what you see in the explorer is exactly what your app runs. Big or binary files (images, archives) show a summary card with a download button instead of opening as text.

Building a site is half the job - people need to find it. Your Playcode AI can now research real search data while it works on your project:

• Keyword research. Ask "what keywords should my site target?" and get real Google search volumes, difficulty scores, and search intent - not guesses. It can also pull the full keyword list any competitor ranks for.
• Backlink intelligence. See who links to any site: total authority, top referring domains, and the exact linking pages. Great for finding sites that link to your competitors but not to you yet.
• Live Google results. Check who actually ranks for a search today - and whether your site shows up.

Just ask in chat: "find low-competition keywords for my bakery site", "who links to my competitor?", or "where do I rank for handmade candles?". The AI pulls the data, reads it, and turns it into a concrete plan - new pages, better titles, link targets.

Available on paid plans. Each lookup uses a small amount of credits (about the same as generating an image), and repeated identical lookups within a day are free.

Your Playcode AI can now hand heavy work to background agents - and stay available while they run.

• It keeps talking while they work. Ask for research, an audit, or a build slice "in the background" and the AI starts a task, tells you the id, and keeps the conversation going. When the task finishes, the result lands right back in your chat.
• A tasks panel in the editor. See every background task with a live status - queued, running, finished - how long it's been going, and a stop button while it's alive.
• Every task is a real chat. Open any task to watch the agent work message by message, exactly like your main chat. Type into it to steer a running agent mid-flight, or message a finished one to continue where it left off.
• Built-in quality loop. For bigger builds the AI can run build -> audit -> fix cycles: a coder agent implements, an auditor agent reviews against your requirements and returns a concrete verdict, and fixes get their own task - before the result comes back to you.

Long tasks no longer look like a hang: if an agent hits a limit, you get the partial result and can send it a follow-up to continue. Tasks even survive our own deploys - they resume from their chat history instead of failing.