> ## Documentation Index
> Fetch the complete documentation index at: https://predev.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Agents: start with https://docs.pre.dev/agents.md, which has complete recipes, plan access, polling rules, errors and limits.
> Authenticate with the workspace API key (pdk_…) from Integrations → Built-in, sent as Authorization: Bearer <key>.
> REST API: https://api.pre.dev (OpenAPI: https://docs.pre.dev/api-reference/openapi.json). AI Gateway: https://api.pre.dev/v1, OpenAI-compatible (OpenAPI: https://docs.pre.dev/api-reference/ai-gateway.openapi.json).
> pre.dev MCP server: npx -y @predotdev/mcp setup adds it to every local coding agent with every pre.dev tool plus the user's own Chrome; the hosted server is https://api.pre.dev/mcp. Search these docs over MCP at https://docs.pre.dev/mcp.

# Changelog

> What's new in the pre.dev API and SDKs.

User-facing changes to the pre.dev API, SDKs, and dashboard. Subscribe via
the [GitHub releases page](https://github.com/predotdev/predev-api/releases)
to get notified on every SDK bump.

## 2026-10-12

### Chat-only projects, in one Projects list

* Every folder you run `predev` in is a project. A folder without code starts **chat only**: the agent and all of its tools, with no keys, database, or file sync until you build something there. It becomes a **full project**, with Plan, Code, and Preview, when the agent writes code, a plan or build starts, or you type `/project`. See [Chat-only and full projects](https://predev.mintlify.site/cli/chat-only-projects.md).
* On the web, chat-only projects are in your Projects list with a **Chat only** tag and where they run, and the separate Sessions list is gone. A chat-only project you opened but never wrote in stays out of the list.
* A chat-only project's page has a **Chat only** tag, shows Plan, Code, and Preview switched off, and has a **Make it a full project** button; they switch on in the open page when it becomes one.
* In the CLI, the top bar shows **chat only** until the project is full, the first line says what that means, and `predev --help` describes both.

## 2026-10-11

### Sessions that move to the cloud can build

* When a session's message runs in the cloud (**Run in the cloud instead** on the web), its cloud workspace starts with it. Once the agent writes code or starts a build there, the session becomes a project and **Code** and **Preview** appear.

## 2026-10-10

### CLI: sessions and projects

* **A folder without code opens a session.** `predev` in a folder with no code, or in your home folder, Desktop, Downloads, or Documents, starts a session: a chat tied to 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, sets up no git, makes no build suggestions, and does not appear in Projects. See the [pre.dev CLI](https://predev.mintlify.site/cli/overview.md).
* A folder that holds code (a git repo, an app manifest, or source files), a folder already linked to a project, and `predev open <project>` open a project as before.
* **A session becomes a project when building starts**: the agent writes code into the folder, a plan or build starts, or you run `/publish` or `/project`. The CLI says so in one line and starts what was off.
* A project made from a session, or with `/project` in an empty folder, gets only the keys you set for the project in its `.env`.
* `predev open <session>` opens a session in the folder it last ran in, or in `~/predev-sessions/<name>` when that folder is gone.

### Sessions on the web

* A **Sessions** page, next to Projects, lists your CLI sessions with where each one is (working, online, offline, or in the cloud), messages waiting for it, its last message, and a search.
* **New session** starts pre.dev on your computer, or shows the command to run. Each session can be opened on your computer, renamed, made a project, or deleted.
* A session's page is the agent chat alone: no Plan, Code, Preview, or Publish until it becomes a project. Messages sent while your computer is offline wait for up to 7 days and run when the CLI opens again, or choose **Run in the cloud instead**.
* An answer to the agent's question given on the web goes to the computer that asked it and closes the question there.

### Browser Agents Local in the CLI starts faster

* [`@predotdev/mcp`](https://www.npmjs.com/package/@predotdev/mcp) 2.2.2 adds `npx -y @predotdev/mcp install-app`, which installs or updates the self-updating copy with no sign-in and no change to your agents' settings. The CLI runs it in the background, so `/chrome` starts without an npm lookup. See [Browser Agents Local in the CLI](https://predev.mintlify.site/browser-agents/local.md#use-it-in-the-cli).
* In the CLI, the agent is no longer offered screenshot tools from local MCP servers, since it receives their text only.
* `!cmd` keeps square brackets exactly as typed.

## 2026-10-09

### pre.dev MCP 2.1.6 to 2.2.1

* **Setup works before you sign in.** `npx -y @predotdev/mcp setup` installs the server, adds it to your agents, and connects to Chrome first, then asks you to sign in. Press Enter to skip; `chrome_act`, plain-words waits, and the cloud tools work after `npx -y @predotdev/mcp login`. See [Browser Agents Local](https://predev.mintlify.site/browser-agents/local.md#quick-start).
* **Pages are loaded when tools return.** `chrome_open` and `chrome_navigate` wait for the new page, clicks and key presses give it up to 2 seconds to update, and `chrome_wait` with only a tab waits until the page stops changing. Open and navigate end with **Page loaded**, or say the page is still loading after 20 seconds.
* **Leaner reads.** `chrome_read` leaves out site menus, footers, off-screen panels, and the options of long dropdowns (`full=true` keeps them). `selector` reads only the matching elements and `links` adds their URLs. Link URLs lose tracking parameters, and sponsored redirects resolve to where they lead.
* A `chrome_read` selector that matches nothing, or a `chrome_wait` selector that times out, lists the page's repeated items with selectors that work.
* Results name the Chrome profile, and a call without `tab` uses the tab this agent last worked in.
* **The installed copy updates itself.** It checks npm at most every 6 hours and verifies the download, and the running server uses the new version from its next call. Set `PREDEV_MCP_AUTO_UPDATE=off` to turn this off.

### CLI

* Text pasted on the first screen (**What do you want to build?**) no longer disappears.

## 2026-10-08

### pre.dev MCP 2.1.4 and 2.1.5

* Agents finish a browser task with the closest answer the pages show, and say what differs, instead of stopping to ask. They still ask you for sign-ins, passwords, and payments.
* `chrome_snapshot` lists the URL each link goes to.
* Updates no longer make Chrome ask **Allow remote debugging?** again, and tool fixes reach a running server without reconnecting.
* `chrome_act` takes `target`, or `description`, `instruction`, `element`, or `query`; `chrome_wait` takes `condition` or `until`. Both say what they need when given nothing.

### `/chrome` in the CLI

* The agent uses your signed-in Chrome for real websites and its own headless browser for the app it is building.
* Plain-words actions work whether you signed in to the CLI in the browser or with `PREDEV_API_KEY`.
* `/chrome` is listed in `predev --help`.

## 2026-10-07

### Your own Chrome in the pre.dev CLI

* **`/chrome`** in the [pre.dev CLI](https://predev.mintlify.site/cli/overview.md) lets the agent open tabs, read pages, click, and type in the Chrome you already use, in every profile and signed in as you. It uses your CLI login and needs Node.js 22 or later. `/chrome off` turns it off. See [Browser Agents Local in the CLI](https://predev.mintlify.site/browser-agents/local.md#use-it-in-the-cli).
* **`predev mcp setup`** adds the [pre.dev MCP server](https://predev.mintlify.site/architect-agent/mcp-setup.md) to your other coding agents, such as Claude Code, Codex, and Cursor.
* `npx -y @predotdev/mcp setup` now adds the server to the pre.dev CLI too, and uses your CLI login when you are signed in there.
* When a local MCP server returns an image, such as a screenshot, the CLI saves it as a file and gives the agent its path.

### The pre.dev MCP in every agent

* `npx -y @predotdev/mcp setup` now also sets itself up in Hermes, Pi, OpenClaw, GitHub Copilot CLI, Antigravity, Cline, Kiro, Qwen Code, Factory Droid, Augment, Amp, Kilo Code, Zed, Kimi Code, Junie, Warp, Rovo Dev, OpenHands, LM Studio and VS Code Insiders, on top of the agents it already covered. See [manual setup](https://predev.mintlify.site/browser-agents/local.md#manual-setup) for the rest.
* Agents without MCP can use every tool from a shell: `npx -y @predotdev/mcp tools` lists them and `npx -y @predotdev/mcp call <tool> '<json>'` runs one.

### Switch from Claude in Chrome

* **[Switch from Claude in Chrome](https://predev.mintlify.site/browser-agents/switch-from-claude-in-chrome.md)**: move your coding agent to Browser Agents Local in two steps, with a tool-by-tool map from Claude in Chrome's tools to the `chrome_*` tools. Your Chrome profiles, tabs, and logins carry over.

### pre.dev MCP 2.1.2 and 2.1.3

* `chrome_open` and `chrome_navigate` read `localhost:3000` and other host-and-port addresses as hosts, and open local and private-network addresses over http.
* Plain-words waits see the page's fields, as `chrome_act` does.
* Plain-words actions mask password, card, security code, one-time code, and secret-named fields, and drop token-like values from URLs, before anything is sent to pre.dev. See [Safety](https://predev.mintlify.site/browser-agents/local.md#safety).
* The server's files under `~/.predev/mcp` are readable only by you, and `chrome_upload` and `file://` opens refuse SSH keys, cloud credentials, `.env` files, the saved pre.dev key, and Chrome's own data.

### AI Gateway: auto-recharge before a 402

* When a `/v1` call finds the workspace short of credits and auto-recharge is on, pre.dev refills first and runs the call instead of answering `402`. See [Errors](https://predev.mintlify.site/api-reference/errors.md).
* The `topup_url` in an `insufficient_credits` error, `https://pre.dev/billing`, now opens the plans for a free account and credits for a subscriber.
* `insufficient_credits` carries `trial_blocked` when the workspace's free credits are on hold, for example until its email is verified. Plain-words actions then say to verify the email.

### Plan mode on every plan, and one stop at 0 credits

* `/plan` works on free plans too, in the web workspace and the CLI. At 0 credits a plan is refused before any work starts, with **Subscribe** or **Buy credits** next to it.
* The composer's plan chip shows only while plan mode is on, to turn it off; turn plan mode on with `/plan`.
* 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. A refused message, a paused preview, and a stopped publish name the same fix.
* On a project another account pays for (its owner, or a team), the chat checks and shows that account's balance.

## 2026-10-06

### The pre.dev MCP server: one command, every pre.dev tool, and your own Chrome

* **One command sets it up.** `npx -y @predotdev/mcp setup` signs you in to pre.dev in the browser, or creates a free account, and adds the pre.dev MCP server to every coding agent it finds on your Mac: Claude Code, Codex, Cursor, Windsurf, VS Code, Gemini CLI, OpenCode, and Claude Desktop. It registers the server as `predev` and connects to Chrome. Running it again updates to the newest version. See [Connect the MCP server](https://predev.mintlify.site/architect-agent/mcp-setup.md).
* **Every pre.dev tool in one server.** The local server passes through the hosted tools on your key: `browser_agent`, `browser_agent_get`, `browser_agent_list`, `fast_spec`, `deep_spec`, `get_spec`, `list_specs`, and `get_plan`. Setup replaces a pre.dev server you added before, such as the hosted one, because the local server carries all of its tools. The hosted server at `https://api.pre.dev/mcp` keeps working for clients without Node.js.
* **[Browser Agents Local](https://predev.mintlify.site/browser-agents/local.md): your own Chrome.** 17 `chrome_*` tools let your coding agent drive the Google Chrome you already have open: every profile, your logins, and your open tabs. All your agents share one connection, so Chrome asks **Allow remote debugging?** once each time it starts. See [Cloud or Local](https://predev.mintlify.site/browser-agents/local.md#cloud-or-local) to choose.
* **Plain-words actions**: `chrome_act` clicks or types into an element you describe, and `chrome_wait` can wait for a plain-words `condition`. They use your workspace credits and appear in [`GET /v1/usage`](https://predev.mintlify.site/ai-gateway/api/usage) as `browser-agents-local`. Every other Chrome tool runs on your computer and never calls pre.dev.
* Free and open source under MIT: [`@predotdev/mcp`](https://www.npmjs.com/package/@predotdev/mcp) on npm, source at [predotdev/mcp](https://github.com/predotdev/mcp). `check` confirms the setup, `login` signs in again, and `uninstall` removes it from every agent.

### Plans list additions under their feature

* In [`GET /get-plan`](https://predev.mintlify.site/architect-agent/api/get-plan), the MCP [`get_plan`](https://predev.mintlify.site/mcp/tools#get_plan) tool, and the `plan` in [spec status](https://predev.mintlify.site/architect-agent/api/spec-status.md) and `get_spec`, work added to a feature that was already built is listed right after that feature, with `partOf` naming it, and counts as its own item until it is built. On a feature, `partOf` is `null`.
* The Markdown summary says `(added to <feature>)` and counts features and additions separately.

### Plan mode is back on the web

* On paid plans, the **Plan** chip and `/plan` turn on plan mode in the web workspace again, and `/auto` turns it off.
* Plan mode now stays on until you leave it. Each message changes the plan instead of the code and ends with a **Plan updated** card: the stories added, changed, or removed, the spec version, and the credits used. **Build it** leaves plan mode and starts building. `/plan` in the CLI works the same way.
* A first message that asks for a plan and no build yet, such as "Plan only, don't build yet: a habit tracker", plans the app without building it and opens the Plan view on a **Plan ready** card.
* The Plan view's tabs (Overview, Document, Roadmap, Architecture, Spec, App map, and Changes) read the same plan, and each says when it last changed.

## 2026-10-05

### Project plans through the API and MCP

* **[`GET /get-plan`](https://predev.mintlify.site/architect-agent/api/get-plan)** returns a project's verified plan by `specId` or `projectId`: what the app is for, each feature's status from pre.dev's checks, progress, Ready to launch with a plain fix for each open item, and where screens, API routes and stored data live in the code. Add `format=markdown` to get the Markdown summary alone.
* **The MCP server has a `get_plan` tool** with the same plan, for a coding agent to read before it works on a project. See [get\_plan](https://predev.mintlify.site/mcp/tools.md#get_plan).
* [Spec status](https://predev.mintlify.site/architect-agent/api/spec-status.md) and `get_spec` carry the plan as `plan` once a spec is completed.
* Reading a plan uses no credits.

### Progress counts features, and "works" comes from checks

* Progress now counts the features of your plan (for example **3 of 4 built**), and the **App map** shows each feature's status, from **Planned, not built** to **Works, checked … ago**. See [How progress is counted](https://predev.mintlify.site/coding-agent/building/progress-tracking.md#how-progress-is-counted).
* A card after each run shows what changed, whether the app runs and builds, and which features its checks confirmed.
* **Build next** picks the next feature from the plan, and work a sprint builds stays **Built, not checked yet** until a check confirms it.

## 2026-09-27

### CLI: sign in with an API key, and run one task with `predev run`

* **Sign in without a browser.** Set `PREDEV_API_KEY` to your workspace API key and the CLI signs in with it when the computer has no saved login, as in CI, coding agents and fresh machines. A saved browser login still wins. See [Sign in without a browser](https://predev.mintlify.site/cli/overview.md#sign-in-without-a-browser).
* **`predev run "<prompt>"`** sends one request to the agent in the current directory, prints the result, and exits: `0` finished, `1` failed or stopped, `2` not signed in or the key was rejected. With no prompt argument it reads the prompt from stdin. See [Run one task without the app](https://predev.mintlify.site/cli/overview.md#run-one-task-without-the-app).
* **`predev logout`** forgets the saved login on this computer, so the CLI signs in with `PREDEV_API_KEY` when it is set.

### Documentation for agents

*Documentation update. No product change.*

* **[Guide for agents](https://predev.mintlify.site/agents.md)** covers the interfaces, the API key, plan access, five complete recipes, polling and error rules, and limits. It comes first in [llms-full.txt](https://docs.pre.dev/llms-full.txt).
* **[llms.txt](https://docs.pre.dev/llms.txt)** is written by hand: agent entry points first, then every page by tab with a unique title.
* **[skill.md](https://docs.pre.dev/skill.md)** is reviewed by hand. Install it with `npx skills add https://docs.pre.dev`.
* **The AI Gateway has an OpenAPI file**, [ai-gateway.openapi.json](https://docs.pre.dev/api-reference/ai-gateway.openapi.json), covering all 25 `/v1` operations with error examples. Every operation has a reference page, and every REST response in [openapi.json](https://docs.pre.dev/api-reference/openapi.json) now has an example.
* The docs search server for agents is at `https://docs.pre.dev/mcp`.

### AI Gateway: a model list without a key, credit-only prices, and workspace-scoped files

* [`GET /v1/models/public`](https://predev.mintlify.site/ai-gateway/api/public-models) lists every model an app can call, with its lab, type and modalities, and needs no API key. Credit prices stay on `GET /v1/models`.
* The catalog listings carry prices in credits only, in each row's `predev` object. When the catalog cannot be read, they answer `502` with code `catalog_unavailable`.
* [`GET /v1/usage`](https://predev.mintlify.site/ai-gateway/api/usage) reports requests, credits and tokens only, and `workspace` is an opaque `ws_…` id.
* [`GET /v1/files`](https://predev.mintlify.site/ai-gateway/api/list-files) lists only files this workspace uploaded, 20 per page by default and at most 50, paged with `after`.
* Video jobs are polled and downloaded by the `id` their submit response returns.
* A request that refers to another workspace's file, response, or video job returns `404` before anything runs.

### MCP tools say what they do and cost

* Tool descriptions and [`/mcp/info`](https://api.pre.dev/mcp/info) say what each tool does, when it helps, and what it costs. `get_spec` and `list_specs` use no credits.
* `get_spec` returns `creditsUsed`: the credits recorded so far for the spec's project.

## 2026-09-26

### Agent Skills and sign-in for MCP servers

* **Skills follow the Agent Skills format.** Paste a `SKILL.md` or upload a skill folder as a `.zip`. The agent sees each skill's name and description and loads the rest only when a task needs it.
* **Remote MCP servers can sign in with OAuth.** Add the server's `https` URL in Integrations and approve access, instead of pasting a token.
* Local command (stdio) MCP servers run only from the CLI; the web workspace uses remote servers.

### A project header that fits any window

* The header no longer overflows at narrow widths. The **Sandbox** chip shows its status, with CPU and memory on hover, and **Publish** is a rocket icon.
* Clicking the Sandbox chip explains where the project runs and how to work on it from a terminal: install the CLI, then `predev open`.

## 2026-09-25

### Plan mode removed on the web

* The web workspace no longer has a Plan toggle or the `/plan` and `/auto` commands. The agent decides when to plan before it builds.

### CLI: publish, usage, undo, and more

* `/publish` and `/unpublish` put the app on its live address or take it down.
* `/usage` lists what the project's credits went on, turn by turn.
* `/undo` and `/redo`, with a checkpoint before every run on your machine.
* `/rename`, `/logout`, `/mcp add` and `/skills add`.
* Up and down arrows recall earlier prompts, each session tab keeps its draft, and suggested next messages appear after a turn.

## 2026-09-23

### AI Gateway: choose a model, not a provider

* Responses carry pre.dev generation ids (`pdg-…`), which [`GET /v1/generation`](https://predev.mintlify.site/ai-gateway/api/generation) accepts. `usage` no longer includes cost fields: read the charge from `x-predev-credits-charged`, or from `GET /v1/generation` for a streamed call.
* A `provider` object in a request is ignored, and `/v1/providers` and the per-model endpoints lists are gone. Choose a model id from `GET /v1/models`, and send `models` for fallbacks.
* Errors from the model keep their status and message.

### Browser Agents: leaner results

* Task results and events no longer include `totalTokenUsage` or `llmCallsUsed`. Data, credits, status and step counts are unchanged.

## 2026-09-22

### Publish apps to a live address

* **Publish** in the project header builds a production version of the app at its own pre.dev address, or your own domain. Every publish is kept as a version, and you choose who can open it.
* Ask the agent to publish or unpublish; it checks with you first.
* Share leads with two links: **Live**, the published app, and **Draft**, your latest changes.
* Free plans publish for 7 days; Premium and above keep apps live and can add a custom domain. See [Publish](https://predev.mintlify.site/coding-agent/building/publish.md).

### WebMCP

* Forms and actions the agent builds are registered as WebMCP tools that run the same handler as the button, so AI agents in the browser can use your app directly.
* Browser Agents call a site's WebMCP tools when it registers them, and work the page as before when it does not.

## 2026-09-17

### Integrations opens on a Built-in tab

* The workspace API key, the model catalog and payments are on **Integrations → Built-in**. Each project's settings has a Test or Live switch for payments.

## 2026-09-16

### AI Gateway: hundreds of models inside every app

* `https://api.pre.dev/v1` serves hundreds of models from every major lab through one OpenAI-compatible API, plus the Messages format: chat, Responses, embeddings, rerank, images, video, speech and music, transcription, and files.
* Every project built on pre.dev gets the workspace key as `PREDEV_API_KEY`, and calls are charged to the workspace's credits. The catalog at `GET /v1/models` lists credit prices per model. See the [AI Gateway](https://predev.mintlify.site/ai-gateway/overview.md).

### One API key per workspace

* Each workspace, personal or team, has one fixed key that starts with `pdk_`. It authenticates the REST API, the MCP server, Browser Agents and the AI Gateway. Existing keys keep working.
* Rotating the key keeps the old one valid for 15 minutes.

### Payments built in

* Apps built on pre.dev take payments with no setup: checkout, subscriptions and webhooks work in test mode while you build. To take real payments, connect an account you own and switch a project from test to live. See [payments](https://predev.mintlify.site/payments/overview.md).

### Faster code browsing, with editing when you need it

* **Code opens as a viewer.** Browse generated files, search names and contents, copy code, and inspect unified or split changes without loading a full editor.
* **Choose Edit for manual changes.** Find and replace, undo and redo, reset, and saving remain available. Switching files keeps drafts; failed saves can be retried.
* **Large files stay responsive.** They open in plain text with optional syntax highlighting. Mobile uses a file drawer and wrapped unified diffs.

See [The workspace](https://predev.mintlify.site/coding-agent/workspace.md#inspect-and-edit-code) for the controls and shortcuts.

## 2026-09-14

### CLI projects stay local

* A project created in the CLI and opened on the web no longer starts a cloud sandbox or reseeds a template over your local files, even when it has a GitHub remote.

## 2026-09-07

### Reject unusable browser tasks before starting work

* The dashboard now keeps Run disabled until each task has a valid website URL and instructions or an output schema, with inline guidance and consistent URL normalization for drafts and CSV rows.
* The backend checks task input and DNS before charging or queueing, so empty tasks and nonexistent domains do not consume sandbox time. Output-schema-only extraction remains supported.
* Permanent task and URL failures no longer get another sandbox attempt. Failed runner outcomes display as failed in the run details.

## 2026-09-06

### Browser Agents API: task `mode`

* `POST /browser-agent` accepts `mode` per task: `extract` for schema-driven extraction, `agent` for step-by-step interaction with a completion check, or `auto` (the default) to choose. Requests without `mode` behave as before.

## 2026-08-20

### CLI projects on the web dashboard

* Projects started in the CLI appear in the web dashboard's Projects list.

## 2026-08-02

### `predev --version` and `--help`

* Both print and exit instead of opening the terminal UI, so they work in scripts and CI.

## 2026-07-25

### MCP specification tools report failures

* `fast_spec`, `deep_spec` and `get_spec` report a failed generation as a failure, with the reason.
* `get_spec` reports a specification that is still generating as in progress instead of returning an error (since 2026-07-22).

## 2026-07-21

### CLI commands and per-project integrations

* `/clear` resets the feed, `/help` lists every command, and `/integrations` shows what is connected and opens setup in the browser.
* MCP servers and skills can be scoped to one project, with a list of what each build can use and where it came from.

## 2026-07-15

### Act from your inbox, and a much snappier app

* **Answer the agent's questions straight from email.** If the agent asks a clarifying question while you're away, the email now has one-click answer buttons: tap your choice and the build picks up immediately. Links are signed and safe from email scanners.
* **Credits run out mid-build? You get the full picture.** The build pauses safely and you receive an email with current progress, screenshots, and the live preview link. Top up and resume where it left off. A "we'll email you when it's ready" cue now appears during sprints so you can close the tab with confidence.
* **A broad speed pass.** The dashboard, opening a project, and chat are all significantly faster, and the hottest screens paint instantly from cache.
* **Renaming a project keeps old links working**, and builds now survive server restarts and idle timers instead of stalling.

## 2026-07-13

### Watch the agent think, and dial the effort

* **Live thinking ticker.** While the agent reasons, its thinking streams in real time; finished reasoning collapses into a "Thoughts" block you can expand later.
* **Effort levels.** Choose how deep each sprint goes with `/effort`: **low** (fast direct pass), **medium** (task-list loop), or **high** (full research → code → verify pipeline), with **auto** routing each sprint for you by default. See [How the agent works](https://predev.mintlify.site/coding-agent/building/build-modes.md).
* **Fewer unnecessary questions.** The agent now asks clarifying questions only when it genuinely needs an answer, and pings you when a direct sprint finishes.
* **Cleaner parallel-agent view** with per-branch objective, progress, and conclusion.

## 2026-07-09

### The terminal-style workspace, on the web

* **Terminal chat everywhere.** The web workspace now matches the CLI: a terminal-style chat with a `/` command palette (`/sprint`, `/effort`, `/model`, `/balance`, `/fork`, and more) and live view tabs for Plan, Code, and Preview. See [The Workspace](https://predev.mintlify.site/coding-agent/workspace.md).
* **The pre.dev CLI** brings the same agent, slash commands, and views to your terminal.
* **Before/after screenshot evidence** on every browser verification step: see exactly what the agent checked and what changed.
* **Builds pick themselves back up.** Interrupted sprints resume automatically instead of waiting for you to notice.

## 2026-07-08

### Generate images, video, and audio inside your build

* **Images, video, audio, and music in chat.** Ask the agent for a logo, a hero video, a voiceover, or a soundtrack mid-build; the generated files land directly in your project.
* **More reliable builds against your acceptance criteria**, with a hardened verification loop.
* Faster, cheaper generated images, and GitHub sync no longer breaks from build cache.

## 2026-06-25

### Parallel agents you can actually inspect

* **The parallel-agent panel shows real work**: per-agent live streaming, full tool detail, and real file diffs as multiple agents fan out across a sprint.
* **Upgraded coding agent model** across all build paths, plus fixes for the agent getting stuck repeating itself.
* Faster app load and a cleaner agent step view with per-step timestamps.

## 2026-06-14

### Usage-based billing for Browser Agents

* **Pay per task, not per seat.** Browser agent tasks bill against your credit balance, with a per-task minimum. Failed tasks are charged the minimum and nothing more. See [billing and limits](https://predev.mintlify.site/browser-agents/api/run-task.md#billing-and-limits).
* **Tier-aware rate limits** raise throughput for paid plans.
* Typed billing errors with `actionUrl` deep-links (see the 2026-04-30 entry) now cover the full task lifecycle.

## 2026-06-09

### Sessions: fork, merge, and build in parallel

* **Run multiple build sessions at once.** Fork a session to try something risky, work several in parallel, and merge back what works. Merges no longer drop fork edits, even when git is in a bad state.
* **OAuth connectors, MCP servers, and agent skills** arrive in the coding agent: connect your services once and every build inherits them. See [Integrations](https://predev.mintlify.site/coding-agent/integrations/overview.md).
* Secrets and build artifacts now stay strictly out of your GitHub repos.

## 2026-05-26

### Real-time collaboration and mobile preview

* **Multi-session collaboration**: live sync, presence avatars, and per-session status across everyone working on a project. Session forks landed earlier in the month and are now hardened.
* **Mobile preview** with a phone-framed viewport and an Expo QR code for native projects.
* **Much faster returns to a project**: speculative pre-resume from the dashboard and an instant hot path when nothing changed.

## 2026-05-08

### Browser agents join the chat

* **`browser_agent` in the workspace**: the planning agent can now drive a real browser mid-conversation, with an inline timeline card showing every step.
* **Faster and tougher browser automation**: an express path for simple extractions, a form-fill specialist, and stronger stealth for protected sites.
* Queue messages while architecture generation is running; they're picked up the moment it finishes.

## 2026-04-30

### One-click API key copy

A dashboard page to reveal and copy your API key, with sign-in and return for
signed-out visitors. Your key now lives on **Integrations → Built-in**; see
[authentication](https://predev.mintlify.site/api-reference/authentication.md).

### Browser Agents: typed billing errors with `actionUrl`

Non-2xx responses for [`POST /browser-agent`](https://predev.mintlify.site/browser-agents/api/run-task)
now carry a structured body:

```json theme={null}
{
  "error": "Need ~0.5 credits, have 0.00. Buy more to continue.",
  "code": "INSUFFICIENT_CREDITS",
  "actionUrl": "https://pre.dev/projects/browser-agents?upgrade=credits"
}
```

`code` is one of `SUBSCRIPTION_REQUIRED`, `INSUFFICIENT_CREDITS`,
`RATE_LIMITED`, `QUEUE_FULL`, `BATCH_TOO_LARGE`. `actionUrl` (when
present) deep-links the user back to pre.dev with the right billing
modal pre-opened. `window.open(actionUrl)` is enough to send the user
to the credit-purchase or subscription flow without any extra UI.

The same body is emitted on the SSE `error` event when streaming.

#### Node SDK: `predev-api@1.1.0`

```ts theme={null}
import { InsufficientCreditsError, SubscriptionRequiredError } from 'predev-api';

try {
  await client.browserAgent(tasks);
} catch (e) {
  if (e instanceof InsufficientCreditsError) window.open(e.actionUrl);
  else if (e instanceof SubscriptionRequiredError) window.open(e.actionUrl);
}
```

New typed exceptions: `SubscriptionRequiredError`,
`InsufficientCreditsError`, `QueueFullError`, `BatchTooLargeError`. All
non-breaking: existing `instanceof PredevAPIError` checks still match.
See the [Node SDK error-handling docs](https://predev.mintlify.site/architect-agent/sdks/node.md#errors).

#### Python SDK: `predev-api==1.1.0`

```python theme={null}
from predev_api import InsufficientCreditsError, SubscriptionRequiredError
import webbrowser

try:
    client.browser_agent(tasks)
except InsufficientCreditsError as e:
    if e.action_url: webbrowser.open(e.action_url)
except SubscriptionRequiredError as e:
    if e.action_url: webbrowser.open(e.action_url)
```

New exceptions mirror the Node SDK with `action_url` field. See the
[Python SDK error-handling docs](https://predev.mintlify.site/architect-agent/sdks/python.md#errors).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.