Changelog

Writing outside the folder you opened, reading .env and key files, using production credentials and stopping processes by name now ask first, with Allow once or Allow for the rest of this session. /permissions shows these asks along with your own rules.

predev run and predev -p refuse those actions, and leave your Chrome and connected accounts alone, unless you pass --allow (writes, secrets, prod, kill, browser, integrations, or all) or set PREDEV_ALLOW.

The pre.dev MCP server now tells Claude Code, Cursor and other connected agents to read your pre.dev memory before they answer or write anything, code, commit messages and tests included. For an agent that skips a server's instructions, such as Codex, the memory docs give one line to add to AGENTS.md.

A step screenshot's URL is now a private signed link that works for at least seven days. Fetch the run again for fresh links, and download any image you want to keep.

Ampersands, quotes and other symbols in a memory pre.dev saves now read as you typed them.

Memory has three kinds: This project, for everyone on the project; All my projects, yours alone in every project you work in; and Team, which everyone in your organization reads and an admin approves. It applies in every chat, on the web and in the CLI.

pre.dev saves lasting preferences and corrections from your chats on its own, plus short project facts it confirms while working, such as a command that works. Every save shows under the reply with Undo, and you can edit, archive or delete any entry. Say "remember this for the project" or "remember this for all my projects" to save something yourself, or hover any message and choose Remember.

Remembered N things under a reply shows what pre.dev had in mind for it, and the Memory button in the project header opens the Memory panel.

predev memory import brings in the rules you keep for Claude Code, Codex, Gemini CLI, Windsurf, Cline, Continue, OpenCode, Kiro and other agents. On the web, Import takes CLAUDE.md, AGENTS.md, .cursorrules and other files, or Cursor's User Rules, and a guide brings over what ChatGPT, Claude or Gemini know about you. Secrets are refused and never saved.

Open predev in a folder where Claude Code keeps notes and say yes once. The CLI then reads them in place on every run, so it answers from them and new notes count right away. They are never copied into your pre.dev memory.

npx -y @predotdev/mcp setup connects another coding agent to your pre.dev memory, with memory_list, memory_search, memory_remember and memory_forget, so it can read what pre.dev knows and save what you teach it there.

In a project you share, each person's own memory applies to the messages they send, nobody else sees your memory list, and pre.dev learns something personal only from your own messages.

pre.dev can look up what you saved in your other projects, in the same organization or your personal space, and /memory search --all does the same in the CLI.

A project memory that names a file no longer in your code is marked May be out of date, with the reason.

Export on the Memory page downloads a project's memory as AGENTS.md. In the CLI, /memory export writes it into a marked block of AGENTS.md at the repository root.

/memory lists, edits, imports and exports memory, /remember and /forget add and remove entries, and /memory undo takes back the newest change.

An update-ready email quotes what you asked and the start of pre.dev's reply, and a reply email names your message in its subject. Out-of-credits emails say work is paused and nothing is lost, and setup emails name the service to connect.

Two pre.dev runs in the same folder no longer overwrite each other's session.

The CLI's file search uses ripgrep when it is installed and stops after 8 seconds in a very large folder, so the chat keeps moving.

If pre.dev restarts while it is answering, each message you sent during that reply gets its own answer.

When GitLab or Bitbucket stops accepting pre.dev's access, the integration shows that it needs reconnecting.

The default model now runs DeepSeek's October 17 release of V4.1 Flash, with the same reasoning levels. Projects set to DeepSeek V4.1 Flash move to it automatically.

A folder you open the pre.dev CLI in without code is a chat-only project: the chat is saved and on the web, and no files, keys or database are synced. When you build something there (or type /project), it becomes a full project with Plan, Code and Preview. The CLI says which it is in its top bar, and predev --help explains it.

Chat-only projects are in your Projects with everything else, tagged Chat only and showing where they run (on your Mac, or offline). The separate Sessions page is gone, and a chat-only project you opened but never wrote in stays out of the list.

A chat-only project's page carries a Chat only tag, shows Plan, Code and Preview switched off with a note on when they turn on, and has a Make it a full project button. The moment the agent starts building, the page switches to the full project by itself.

When a session's message runs in the cloud, its cloud workspace starts with it. As soon as the agent writes code or starts a build there, the session becomes a project and Code and Preview appear.

Start predev in a folder with no code, or in your home folder, Desktop, Downloads or Documents, and you get a session: a chat you can come back to in that folder, with all of the agent's tools, /chrome and !commands included. A session writes no keys to .env, starts no local database, syncs no files, makes no build suggestions and stays out of your Projects. A folder with code, a folder already linked to a project, or predev open <project> opens a project as before.

When the agent writes code, plans the app or starts a build, or you type /publish or /project, the session turns into a project and the CLI says so in one line.

A new Sessions page, next to Projects, lists your CLI sessions with whether each is working, online or offline, its last message and a search. New session starts pre.dev on your computer, and each session can be opened there, renamed, made a project or deleted. A session's page is the chat: a message sent while your computer is offline waits and runs when the CLI opens again (or choose Run in the cloud instead), and answers to the agent's questions go to the computer that asked them.

Opening a session from the web runs predev open <session>, which opens it in the folder it last ran in, or in ~/predev-sessions/<name> when that folder is gone.

The CLI starts the installed pre.dev Chrome tools right away instead of checking npm first. Without an installed copy, it installs one in the background that keeps itself up to date. The agent is no longer offered screenshot tools whose images it can't see, so it reads the page instead.

!cmd keeps the square brackets you type, and a paste on the first screen no longer leaves stray characters behind.

Answering the agent's question on the web right as it appears no longer fails with "Failed to submit answer". The answer waits for the question to be saved.

Opening a tab or navigating returns once the page has loaded, and a click gives the page a moment to update, so the agent no longer reads a blank page. Reading a page leaves out site menus, footers and slide-out panels, can read just the elements that match a selector along with their links, and product links come back clean, without tracking parameters.

The copy that setup installs checks for a new release every few hours, verifies it and swaps it in, and the next tool call uses it. Opening or navigating a tab says when the page is ready, and a selector that matches nothing lists the page's repeated items with selectors that work.

npx -y @predotdev/mcp setup now adds pre.dev to your agents and connects to Chrome before it asks you to sign in. Press Enter to skip sign-in and finish setup; plain-words actions and the cloud tools work once you run login.

Text pasted into "What do you want to build?" in the CLI now stays in the box.

With Browser Agents Local, your coding agent gives the closest answer and says what differs when nothing matches exactly, instead of stopping to ask. It still asks you for sign-ins, passwords and payments. Snapshots list the address behind each link.

In the CLI, the agent uses your signed-in Chrome for real websites and its own browser for the app it is building, and plain-words actions work however you signed in to the CLI.

Updating the pre.dev MCP no longer makes Chrome ask "Allow remote debugging?" again, and tool fixes reach a running server without reconnecting. chrome_act and chrome_wait accept the argument names agents tend to use.

Haiku 4.5 is retired, and projects and requests set to it now run on Claude Haiku 5.5.

Type /chrome and the agent can open tabs, read pages, click and type in the Chrome you already use, in every profile and signed in as you. /chrome off turns it off. It needs Node.js 22 or later. predev mcp setup adds the pre.dev MCP to your other coding agents.

npx -y @predotdev/mcp setup now also covers Hermes, Pi, GitHub Copilot CLI, Cline, Zed, Kiro, Warp and many more, plus the pre.dev CLI. Agents without MCP can run every tool from a shell with npx -y @predotdev/mcp call, and uninstall removes everything setup added.

A guide on the Browser Agents page moves your coding agent from Claude in Chrome to Browser Agents Local, with a tool-by-tool map. Your Chrome profiles, tabs and logins carry over.

Plain-words actions mask card numbers, security codes, one-time codes and secret fields before a page leaves your computer. The MCP's files on disk are private to your user, and uploads refuse SSH keys, cloud credentials and .env files. Addresses like localhost:3000 now open over http.

Plan mode is no longer limited to paid accounts: /plan works for everyone, free included. With no credits left, a plan stops before it starts, with Subscribe or Buy credits next to it. The plan chip in the composer shows only while plan mode is on, so you can turn it off.

Out of credits, the chat shows one card with one line and one button: Subscribe or Buy credits while the balance is empty, then Resume once credits are back. The banner, a refused message, a paused preview and a stopped publish all name the same fix, and the CLI sends free accounts to plans and subscribers to credits.

With auto-recharge on, a message, an AI API call or a plain-words browser action sent at 0 credits refills first and goes through. An account that has not verified its email is told to verify it to get its free credits.

On a project someone else owns, or a team project, the chat checks and shows the balance that pays for the run. A collaborator is told when the owner is out of credits instead of being offered credits for their own account.

Opening an app whose preview is paused for credits shows a "This app is paused" page with a link to the plans, instead of a spinner that never ends.

Claude Haiku 5.5 is in the picker and /model, with thinking off by default so it keeps building on long requests.

After you press Stop, the Parallel Agents card marks the branches it cut off as stopped instead of spinning forever.

One local server brings pre.dev to Claude Code, Codex, Cursor and any other MCP agent. Browser Agents Local drives the Chrome you already have open, with every profile and login, next to cloud browser agents, specs and plans on the same account. One command sets it up: npx -y @predotdev/mcp setup signs you in, adds it to every coding agent on your Mac in place of an older pre.dev entry, and connects to your Chrome.

Turn on plan mode with the Plan chip or /plan, on the web or in the CLI, and each message changes the plan instead of the code. A Plan updated card lists the stories added, changed or removed, the spec version and the credits it used; Build it starts building, Keep planning stays, and /auto leaves plan mode.

A first message such as "Plan only, don't build yet: a habit tracker" plans the app, builds nothing, and opens the Plan view on a Plan ready card.

Overview, Document, Roadmap, Architecture, Spec, App map and Changes share one tab bar and read the same plan. Roadmap cards sit where the plan says each story is, with the feature they belong to, the Spec tab shows what was added since the spec and what is not built yet, and each tab says when it last changed. The overview document and its share page show the same statuses.

New work on a feature that is already built shows as an addition to that feature until it is built, in progress, Ready to launch and the plan API, instead of as a new feature.

A new loop estimates its runs from what your recent runs cost, /usage lists loop and goal runs on their own, and on a team project a loop or goal says the team's credits pay for it.

When a loop or goal is about to run and the balance is too low, auto-recharge refills first and the run goes ahead, instead of the loop pausing until something else spends.

Output from !commands, files you attach with @ and hook output hide API keys, passwords, tokens and the password in a connection string before anything reaches the model. Each line keeps its name, so the agent still knows what is there.

In a session tab with its own copy of the project, hooks run in that copy and get that session's id.

When a long command the agent left running finishes, the tab that started it picks up the result, not whichever tab you are looking at.

If the balance can't be read for a moment, loops wait and say so, and the status line keeps your last balance instead of showing zero.

When you quit, or the CLI is closed during a turn, the steps your computer already finished are saved to the chat, so the cloud continues from there.

Type /loop 5m check the deploy, or leave the interval out and the agent picks when to look again. A loop runs while predev is open, waits while its tab is busy, never piles up missed runs, and stops at the budget you give it with --max-credits. /loop lists your loops and what they spent, /loop stop ends one. Loops need a paid plan with auto-recharge on.

Tell the agent the condition that means done, like /goal the tests in api/ pass. After each step a separate check reads what the agent ran and decides whether the goal holds. It stops when the goal is met, when the checks stop seeing progress, or at its budget.

Files in .predev/commands or .claude/commands, in the project or your home folder, become slash commands with $ARGUMENTS and positional arguments, and repo skills run as /name. A repo set up for Claude Code works as it is.

!cmd runs a command in this folder right away without starting a turn, and its output goes with your next message. @ opens a file picker and sends the file's text with your message, with a .env file's values left out.

PreToolUse, PostToolUse, UserPromptSubmit, Stop, Notification and SessionStart hooks from .claude/settings.json or ~/.predev/settings.json run on your computer. A project's hooks run once you trust them for that folder, and /hooks shows what runs and what hooks can't see.

predev -p "your prompt" prints the answer and exits, for scripts and CI. --output-format json or stream-json adds what the run did and spent, and --max-credits stops a run at a budget.

/autopay shows your auto-recharge settings and opens them in the browser. When a loop or goal needs a paid plan or auto-recharge, the CLI says what is missing, opens the right page when you press Enter, and carries on by itself once it is set. On a team, it tells you which admin to ask.

Press Enter during a run and your message goes to the running agent, images included, and it reads it at its next step. Commands still wait for the run to finish.

The status line shows the model, how full the context is, what this session spent, your balance, the branch and the next loop run. /context breaks the context down and /compact condenses older messages now, with an optional focus.

Ctrl+R searches earlier prompts, Ctrl+G writes the message in your editor, and Ctrl+J or \+Enter adds a new line. /memory, /export, /copy, /resume, /rewind, /doctor, /feedback and /release-notes are there too, and ~/.predev/CLAUDE.md applies to every project.

On Windows, opening a project no longer stalls on a hidden Git sign-in prompt and keeps the files' line endings, and quitting hands the session back to the cloud faster. On Linux, apps the agent starts on your computer find your tools again.

A message typed while a tab is busy runs on that tab even if you switch tabs. Out of credits, typed messages wait and send in order once you top up, and Alt+Enter adds a new line instead of stopping the run.

Acceptance now runs all of its checks together (the app coming back after a restart, the page rendering, sign-up, payments, and the code and runtime contracts) and hands every failure to a single fix, instead of stopping at the first one and spending a fix cycle on each. It keeps fixing as long as each cycle makes progress, up to 5 cycles, so a build reaches its end-to-end checks instead of running out of attempts on the first few problems.

predev open and a reopen after quitting now read the project, its sessions and its repo access at the same time and join a move that is already underway instead of starting a second one. Pulls bring text files down without waiting for the list of large files, and large files that haven't changed since they last synced are not checked again. The move's progress counts every file, large ones included.

When a cloud workspace wakes from pause, pre.dev now confirms it holds the project's latest files and git history, and restores them if it doesn't before any turn runs. The check runs alongside the wake, so the preview is not held up by it.

Right after a session moves to your computer, the Preview pane keeps showing the app from the cloud until your computer's copy is up, then switches over. It no longer shows the page meant for teammates viewing someone else's computer, or reloads while the move finishes.

Quitting pre.dev on your computer hands its sessions to the cloud right away. If the CLI is killed or the computer goes offline, the cloud usually takes over in under half a minute, whether or not a message is waiting. A task that was mid-turn continues in the cloud from where your computer left off: the step it was running shows as interrupted, messages sent in the meantime run in order after it, and the offline dialog counts down the seconds until the move. Reopening pre.dev in the folder takes the session back.

A session moving between your computer and the cloud now shows its steps live in the runner panel, under the Cloud and Computer switch, and in the CLI: files, packages, app data, the app and the preview on the way to your computer; saving, GitHub and handing over on the way to the cloud. The panel also says when your computer is saving its last changes before a move.

Before a sprint is accepted, the app is restarted the way pre.dev starts it and loaded in a browser, and a blank or crashed page goes straight into a fix instead of becoming a follow-up. Apps using pre.dev's built-in auth are checked by signing up a brand-new user through the app's own sign-up page, including from the Sign up link on the sign-in screen. Apps that take payments with pre.dev Payments are checked to accept a signed payment event. The sprint that finishes the roadmap is also checked against one or two end-to-end journeys written from your original prompt, where each role signs up, creates its own data and hands it to the next.

The first open no longer downloads the repo's full history before starting the app: old versions of files are fetched only when something asks for them. Big files stay out of /undo checkpoints, so turns start without waiting on them in projects with hundreds of megabytes of images or binaries, and quitting right after an open no longer stops to process them.

The roadmap chip shows stories done out of the total (1/9) instead of a percentage that dropped as follow-ups were added, and the CLI's header shows the same number as the web. When a chat turn builds a story from the roadmap, it marks that story done, so the Next task bar moves on.

Marketing pages send much less data, especially to phones, analytics and the booking widget load after the page instead of with it, and the home, pricing, labs and RL tasks pages score 100 on accessibility. The blog now lives at pre.dev/blog, and old post addresses redirect to the matching post.

Merging a cloud copy now waits for the copy's run to finish, so the files its last command wrote come along. Edits on the same line that only change punctuation or a single digit are combined instead of falling back to your version, files deleted in the copy stay deleted, and a merge that waits on your choices lands as one commit.

After a project's GitHub repo is renamed, your computer follows the new name and keeps catching up with the cloud's commits, and branches left by merged cloud copies are deleted after 7 days. When a push from your computer fails, the CLI says why (sign-in, a protected branch, a file too large, the network) and retries it.

Progress and task-ready emails include screenshots of your app again, without the extra labels above them.

The agent's shell in the cloud now starts in your project's folder, so a file it writes with a command lands in the project and reaches GitHub and your computer like any other change.

Chat turns and build tasks now land as commits on your repo's default branch instead of opening a pull request for each turn. A pull request opens only when GitHub has changes pre.dev can't build on directly, and it stays the one pull request until you merge it. Every repo pre.dev creates gets a README that says what the app is, its stack, how to run it and how to keep building with pre.dev.

Your project's preview address now shows the app from the cloud or from your computer, whichever is running the session, so a link you opened or shared keeps working after a switch. During a move it shows a short Moving screen and reloads itself when the app is up.

If the computer running a session goes offline for 5 minutes while messages are waiting, the session continues in the cloud from its last sync. When your computer comes back it takes the session back and keeps any edits it made while offline. You can turn this off for each project.

When a session moves between the cloud and your computer, your app's local Postgres or Mongo development data comes along, so the rows you created are there on the other side. The previous data is kept for 7 days and /db undo puts it back. Hosted databases are never touched.

Start a copy of the session in the cloud from your computer's last sync with /fork cloud or Try something in the cloud on the web. Merging it back combines the changes line by line into your computer's git. Where both sides changed the same lines, pre.dev proposes a combined version for you to review and accept in one click.

Teammates on the project can open the app running on your computer through pre.dev, and stopping the share cuts their access on their next request. A message a teammate sends to a session on your computer arrives as a request you can run there or send to the cloud.

The CLI now signs you in with a short code: go to pre.dev/activate on any device, enter the code and approve. The approval page shows which computer is asking, so sign-in works over SSH, in containers and on machines without a browser, and the CLI starts the sign-in on its own the first time you run it.

The CLI now ships a Windows build that runs in PowerShell and Windows Terminal, with no WSL needed. The install command sets it up and offers to install Git for Windows if git is missing, and the agent's commands run in Git Bash. Opening pre.dev/install in a browser shows the command for your system with a copy button instead of the raw script.

The runner panel's Work on your computer is now a single button. When pre.dev is open on the project on your computer, it offers that computer by name and moves the session there. If the CLI has registered pre.dev links on your Mac or Linux desktop, it opens the project in a terminal. Otherwise it shows the one command to paste. The panel recognizes when you already use the CLI, and on phones it opens as a bottom sheet.

Before you merge a cloud copy, pre.dev lists the files it would bring, with lines added and removed and which ones the main session changed too. Where both sides changed an image or other binary or large file, you see both versions and keep yours or take the copy's, file by file. A merge leaves a line in the main session's chat saying what came in.

Claude Sonnet 5.5 is the picker's Sonnet model and has its point on the cost against quality chart, whose labels no longer overlap the marks or each other. Projects on Claude Sonnet 5 move to 5.5 automatically.

The command you copy from the project installs the pre.dev CLI, signs you in without a browser and opens the project, with a single-use code that expires after 10 minutes. On Windows it installs the native build. The CLI now updates itself in the background, and older versions update on their next launch.

A message sent on the web now starts on your computer in under a second, and after sleep or a network drop it reconnects in about 2 seconds. Stop on the web stops a turn on your computer and the command it is running right away.

The CLI shows a desktop notification when a cloud run, a cloud copy or a move finishes, or a teammate sends a request. On the web, turn on notifications in the runner panel to hear about the same while the tab is in the background.

/push sends images, binaries and large files, renames that only change a letter's case and symlinks inside the project sync both ways, and a small data file the agent writes in the cloud reaches your computer. The Code tab lists large files with download and preview.

MCP servers you added as a command now run on your computer in CLI turns, in the project folder. The web marks them as running on your computer only.

When a project opens on your computer, pre.dev starts the app's own Postgres or Mongo database if nothing else serves it, keeping its files outside the project folder, and starts the app's API server alongside the dev server even when no script runs it. The database is found by reading the app's code, so the right data moves each way, and the web says how much moved. The project's .env on your computer gets only the keys the app uses.

Once a project has run somewhere besides the cloud, each turn in the chat is marked as run on your computer or in the cloud, and a Moved to line shows where the session changed machines. The one-paste command also comes in Cursor and VS Code versions that open the folder in that editor.

While a session moves between your computer and the cloud, the project's preview address serves whichever copy of the app is up instead of an error. A dev server that restarts shows Restarting your app and comes back on its own, a computer that stops responding is shown as Not responding within seconds, and a localhost link in the agent's reply opens your project's preview at the same path.

New files over 25 MB move through pre.dev's storage and stay out of git, on your computer and in the cloud, and a file that grows past GitHub's 100 MB limit is untracked in its own commit, so pushes keep working.

Signing in to the CLI or through pre.dev's OAuth now issues your personal pre.dev API key, the one on the Integrations page. Signing in as an organization issues that member's own key, which stops working when they leave the organization. If you use your account ID as an API key, switch to the key on the Integrations page: account IDs stop working as keys between October 12 and 14, and older CLI sign-ins show a notice to sign in again.

Web builds now start each task as soon as the tasks it depends on are done, instead of waiting for a whole wave to finish, and long research plans and large file writes are no longer cut off partway. Follow-ups say what actually failed.

When a Browser Agent's review of its own answer finds it falls short, and repeating the task is safe, the agent runs one fresh attempt and delivers it only if it checks out. Otherwise you get the first answer as before, and calls that wait for the result get the final one.

When a client closes a streaming request to the pre.dev AI API, generation now stops as soon as the request can be canceled, instead of running on to the end of the answer. This covers chat, completions, messages, responses and speech.

predev open picks up a project in a folder on your computer with its files, large files, keys, connected integrations and git history. The Cloud and Computer switch in the project header moves it back, a session runs in one place at a time so the two never overwrite each other, and both the web and the CLI show where the agent and the preview are running.

Messages you send on the web run on your computer when the session is there, and the web streams the turn as it happens. Choose Move after this turn or Stop and move now to bring it back to the cloud.

Each turn on your computer commits the files it changed, moves push only when the history lines up, and the cloud builds on top of your commits, so GitHub keeps a single history. If a file changed on both sides, your version stays and the other is saved on a branch.

Commits from web builds were not reaching GitHub for most projects. They do again.

Publish in the project header turns your app into a live site at its own pre.dev address, or your own domain. It builds a production version that loads in a fraction of a second and stays up while your workspace sleeps. The header tells you when a newer build is ready to publish, every publish is kept as a version, and you choose who can open it. Free accounts can publish for 7 days with a small Built on pre.dev badge; Premium and up keep apps live with no badge and can add a custom domain.

The agent can publish or unpublish your app when you ask it to, and it checks with you before it does.

Share now leads with two links to your app: Live, the published version, and Draft, your latest changes exactly as Preview shows them, at their own address. Below them are the people who can work on the project, as Can view or Can edit, and a switch for a read-only link to the project's Overview.

When nothing has changed since you last published, Preview shows the published app right away and hands over to your workspace once it answers. While an app starts, the last screenshot stays up until the app has painted, refreshes load behind the current view instead of blanking it, and the Preview tab simply spins instead of spelling out each step.

The model picker adds Claude Opus 5.5, the GPT-6 family (Luna, Sol and Astra), Grok 4.7, Xiaomi MiMo V2.6 Pro and Claude Fable 5.1. Projects pinned to Opus 5, Fable 5, Grok 4.5 or 4.6, or GPT-5.6 Luna or Sol move to the newer version automatically. GPT-5.6 Terra, DeepSeek V4 Flash Vision and DeepSeek V4 Pro leave the picker and projects already on them keep their model; MiMo starts with thinking off, one click from on.

When the agent builds or changes a form or action in a web app, it now registers it as a WebMCP tool that runs the same handler as the button, so AI agents in the browser can use your app directly and normal clicks keep working. The agent's own browser checks call those tools, still confirm the result on screen and after a reload, and finish sooner because the first page visit already lists the page's controls.

A command the agent is running now shows a Cancel button on its card. It stops that command in your project's sandbox, tells you whether it Canceled or found Nothing running, and never wakes a paused project to do it.

Hosted Browser Agents now call a site's WebMCP tools when it registers them and work the page as before when it does not. They keep the exact form values you supply and never repeat a submission that may already have gone through.

Frontier models are labelled on the chart, every model sits inside the plot, and the details card sits below it instead of covering marks. The frontier line has a legend, dimmed models are easier to see, and scores come from the latest Artificial Analysis Intelligence Index, so today's new models are on it.

The Code tab loads the file tree first and fetches a file's contents when you open it, while search still covers every file. Projects with very large repositories now open in the Code tab, and Download code builds a compressed zip on the server and hands you a single download.

The chat on a project page renders without waiting for slower background data, the newest screenshot starts loading with the page, and every page ships a smaller first bundle. While a reply streams, the composer no longer redraws on every frame, and a long Thoughts trace you are reading stays open when the answer starts instead of folding away.

Saving a global environment variable no longer locks chat in each project. The row now reads Saved · on next start: new projects and projects waking from pause pick up the value, and a project that is running right now keeps its current value until it next starts.

The agent now keeps its connections to your MCP servers open across turns, connects to several servers at once and remembers their tool lists, so turns that use MCP tools start sooner. A server that is down is retried once a minute instead of slowing every turn, and connections are never shared between users.

On Claude models the agent now caches the conversation as a run grows, so each step reads earlier turns from cache instead of sending them fresh. Long builds on Opus and Fable use fewer credits per step and start each step sooner.

Pages hold still as they load: the sidebar settles before a page paints and the notices above the workspace show in the first frame. Streaming replies update once per frame, sending a message does less work on long projects, the home, pricing and code licensing pages appear several times sooner, and your repositories on the licensing page load faster.

The project workspace no longer shows a "finished without verifying" banner that could disagree with a Verified result in chat. Before and after screenshots in browser cards fill their frame with no black bars, and a message that mentions two dollar amounts renders as text instead of math.

When a step matches several elements, the agent now picks the one the step's label describes -- the Delete button on the "Buy milk" row, say -- instead of giving up, and a missing selector recovers in about a second. Field checks compare the exact value, a malformed check fails instead of passing, and a failed assertion stops the flow before later steps run. On pages with frames or shadow DOM, explicit selectors are used as written rather than guessed.

A private preview now shows "Waking your app up" while it resumes instead of a blank frame. Waking skips a restart that could not succeed, leaves a dev server alone when it is only slow to answer, spots a freshly started app sooner, and starts older projects with npm when bun is missing.

Your pre.dev API key and Payments now live on a new Built-in tab, the first thing you see on Integrations, and each project's settings get one too with a Test/Live switch for Payments. The tab includes a catalog of every model the key can call, with logos, sort options and filters by input and output type, and Open Stripe works for accounts that have finished onboarding.

Project notification emails have a new pre.dev design with the latest screenshots from the session and a separate link to your hosted app when it has one. Email preferences in the profile menu let you turn project updates or ideas and reminders on and off, and mute a single project.

Opening a saved project now shows each step of bringing Preview back -- reopening the workspace, restoring files, starting the app and checking that it answers -- over the last screenshot, with an elapsed clock that survives switching tabs. A slow start keeps checking in the background, a confirmed failure offers Retry or an agent repair, and on desktop the preview stays loaded when you switch to Agent or change the layout.

The step that decides whether a new project's first prompt should build right away, plan the architecture first or simply get an answer now returns in a fraction of a second. Questions and architecture-first requests reliably get the path they asked for, and apps that need sign-in are recognized from the first turn.

A plain request like a 2048 game now goes straight to writing files instead of a long reasoning pass, and the agent no longer stops for an AI feature or branding you did not ask for. Truncated file output is rejected rather than written as a broken fragment.

The composer now reads "ask pre.dev anything", switches to "answer here…" when the agent has asked you something, and shows the credits-used pill on phones too. The workspace sits flush on desktop with no empty strip above the project header, and Plan opens about twice as fast by loading Roadmap, Architecture and Spec only when you pick them.

The home page's Built in section now covers all three, with a demo for each. The payments and auth demos are real apps pre.dev built, running live in a frame: subscribe with a test card or sign in as a guest without leaving the page.

Account chips under Sync codebases now filter Your repositories as well, with a caption naming the account, how many repos it hid and a Show all link. Add it back re-adds a removed repo in place, the Removed list drops repos you have re-added, and long repo names are no longer cut short by the account chip.

Opening a long thinking trace mid-stream now shows the whole thought, not just its last two lines. Live file-write cards keep their own rows as a turn streams instead of regrouping, and earlier thoughts in the turn stay on screen.

Every dev-server start and restart now loads the project's .env, so variables you add or change, including the built-in AI key, reach the running app after an update or a wake from pause. A variable you remove is gone on the next start.