Ampcode Release Notes

Amp now supports Plaid speed for modes that use GPT-6 Astra. Plaid uses OpenAI's ultrafast speed tier, which enables inference requests to run up to 6× faster, with 6× cost per token.

Open the mode picker in the new thread dialog, choose a mode that uses GPT-6 Astra (e.g., the default High mode), and move the speed switch past Fast to Plaid.

The mode dial with high selected and the speed switch set to Plaid, showing the red 6× cost indicator

Plaid currently works with Amp-provided inference only, as OpenAI does not yet support ultrafast for linked ChatGPT subscriptions. When Plaid is activated, subagents and non-Plaid-enabled model inference will fall back to fast or standard speed. Like fast mode, Plaid can be toggled on or off for an existing thread.

Claude Opus 5.5 now powers Amp's medium mode by default, replacing GPT-5.6 Sol. If you use a ChatGPT subscription with the ChatGPT Only preset, medium stays pinned to GPT-5.6 Sol, billed to your subscription. To switch to Opus 5.5, change medium in Tune Modes.

In our internal evals, Opus 5.5 solved 65% of tasks, up from GPT-5.6 Sol's 61% and Opus 5's 56%. And it did that for 10% less than GPT-5.6 Sol and 25% less than Opus 5.

It's still behind Fable 5.1, which solved 71%, but it costs 40% less.

More Steerable

Opus 5.5 responds much better to messages you send while it works. Add a constraint you forgot, point out a wrong turn, or correct its approach, and it folds that into the work instead of arguing or carrying on with its old plan. It doesn't drop what it was doing, either.

So don't stop it to edit your prompt and start over. Send the correction. Enter steers by default, so your message reaches it right away.

High Effort, Not Max

Opus 5.5 runs at high reasoning effort. Past high, it starts to overthink. At xhigh and max it burns through tokens, scores lower than at high, and costs several times as much. So we stop at high.

Why Not GPT-6 Sol?

OpenAI shipped GPT-6 Sol an hour after Opus 5.5. We ran both. …

Amp now collapses your agent's step-by-step work even more, since you care about what the agent did, not how it got there. (You can still expand the steps when needed.)

A year ago, watching your agent's every step sometimes helped, and you probably were only running one agent.

Now? You have lots of agents. You should be giving them harder, deeper work and verification demands. They should run for longer on their own, without you watching them from up close. If you have the patience to watch your agents work, you're giving them too short a leash.

Ten separate rows of commands, reads, searches, and edits become one expandable summary. Both are followed by the same assistant reply, fading at the second line.

You can now share a runner with your workspace. Start it with --share and everyone in your workspace can start threads on that machine from ampcode.com.

The new thread composer on ampcode.com with the location picker open. Under Runners is your own devbox. Under Shared Runners are gpu-runner, shared by Allison, and macos-builder, shared by Monty, each with its owner's avatar and running-thread count.

If you have a machine with GPUs, a Mac that's used to build and sign the iOS app, or a dev box in a specific network, you can now set it up and the whole team can spawn agents on it:

$ amp --no-tui --runner-id macos-builder --share

Everyone in your workspace now sees it in the picker under Shared Runners.

With --amp-env, a shared runner gets the workspace and project Secrets & Env Vars, but never your personal ones. That applies to your own threads on it too.

We need to offer a word of warning, though: everyone you share with runs code on your machine as you, with your files, your credentials, and your logins. Their threads can also work in the same directories at the same time. So only share a runner with people you'd trust with a shell on that machine. Even better, give the runner a machine of its own. (Better still: use orbs, so that every thread gets its own machine.) …

The Amp app for macOS now starts a runner for you. You no longer need amp --no-tui open in a terminal to run threads on your Mac.

The Runner tab in the Amp app's settings on macOS. Use This Mac as a Runner is switched on, the status says Running with 3 folders and 2 threads, the runner name is hamishs-macbook-pro, Keep This Mac Awake is switched on, and the Folders list shows amp, sandcastle, and marketing-site.

Open App Settings… (⌘⇧,), go to Runner, and click + to add a folder or one of your projects. Start a thread and your Mac is right there in the picker, marked This Mac. You can also pick it when you start a thread from ampcode.com, your phone, or Puck.

The new thread composer in the Amp app with the prompt Make amp an iPhone Duo app and the ultra mode. The runner picker is open, and hamishs-macbook-pro is selected with a This Mac capsule and a MacBook icon. Below it is hamishs-dgx-spark, another runner, with no capsule.

No More Sleeping on the Job

Keep This Mac Awake stops your Mac from going to sleep while the runner is on and the Mac is plugged in, so you can still start threads on it after you walk away. The screen still turns off and locks. On battery, or when you close the lid, your Mac sleeps as usual.

Read more in the runner docs.

A runner can now create Git worktrees. Pick a repository the runner serves, hit Tab, name the branch, and the thread starts in a fresh checkout. Your main checkout stays untouched.

The new thread composer on ampcode.com with the runner mac-mini selected and the directory picker open. The amp repository is highlighted and offers Current or New Worktree.

In the directory picker, every Git checkout on the runner gets a New Worktree option next to it. Choose it and you get a small form:

The worktree form in the new thread composer: New worktree of amp, name fix-flaky-login-test, directory ~/code/amp-fix-flaky-login-test, branch fix-flaky-login-test, from current HEAD, and a Create Worktree button

The name you chose becomes the branch name and the folder name. The runner then creates the worktree as a sibling of the repository: ~/code/amp gets ~/code/amp-fix-flaky-login-test, checked out on a new branch fix-flaky-login-test off the current HEAD. Uncommitted changes stay where they are, in the original checkout. The new directory shows up in the picker right away, marked with a branch icon, and the thread starts in it.

Puck can do this too: ask it to start a thread on your runner in a new worktree and it passes a worktree name to create_thread.

Clean Up When You're Done …

A runner can now serve many directories, not just the one it was started in. You can point it at specific projects and directories or let it find your Git repositories.

The new thread composer on ampcode.com with the runner mac-mini selected and a picker listing its projects and folders

Start a runner and tell it which directories to serve with --dir. Repeat the flag for each one:

$ amp --no-tui --runner-id mac-mini --dir ~/code/amp --dir ~/code/sandcastle

Or start it in the directory that holds your checkouts and let it find them:

$ cd ~/code
$ amp --no-tui --runner-id mac-mini --discover-dirs

--discover-dirs serves every Git checkout up to two levels beneath the current directory and picks up new ones as you clone them.

Checkouts somewhere else, or deeper than two levels? Give --discover-dirs a path, repeat it for more, and set --discover-depth to look further down:

$ amp --no-tui --discover-dirs=~/work --discover-dirs=~/code --discover-depth 4

Add or remove directories while the runner is running, without restarting it:

$ amp runner dirs add ~/code/new-repo
$ amp runner dirs list
$ amp runner dirs remove ~/code/dotfiles

The runner remembers the directories you add this way and serves them again the next time you start it from the same directory. …

Amp is now free to use when you bring your own compute and model subscriptions/keys.

• No monthly plan is required anymore to use your ChatGPT subscription with Amp.
• No BYOK token fees or limits for anyone (except our Enterprise tier).

You pay us for orbs, our remote computers where your agents run independently and in parallel. Or you can use runners on your own computers to run your Amp agents for free.

You can still pay for model inference through Amp if you want, with no markup.

Here's our new free Hobby tier and no-extra-charge Teams tier, which make it easier to get started with Amp and to get your whole team on it:

See Pricing for full details, but let's walk through what changes and what doesn't.

For Amp Megawatt & Gigawatt Members

On average, Megawatt members get a 60% discount and Gigawatt members get a 65% discount on their Amp usage. It's a great deal.

You'll keep getting the same heavily discounted orb usage and model usage each month, plus you can now feed your orbs with tokens from more places.

With this change, you're no longer effectively bound by the limits of your ChatGPT sub. You can tap other model providers or your company's preferred AI gateway/provider (more on that below), all without any Amp token fees or limits.

For Teams

We've eliminated the biggest sources of friction you might hit when spreading Amp, cost-wise and security-wise. …

You can now choose the models behind Amp's builtin modes and put your own agents on the Dial. There are two tabs in Settings → Mode Dial.

Tune Your Modes

In Tune Modes, choose the model and reasoning effort for a builtin mode's main agent, Oracle, or subagents. Use it to run those models through your own API key or ChatGPT subscription. The mode keeps its prompt and tools.

Tune Modes with high selected, the Oracle pinned to GPT-6 Astra, and the main agent and subagents left on Auto

Connect your key or subscription in Model Routing, then choose models it supports. You can change just the Oracle, or all three roles. Anything left on Auto follows Amp's choices as models improve.

Billing follows your provider connections.

Build Your Own Dial

If you often find yourself using custom agents you built with plugins, like a dedicated code reviewer or a security agent, you can place them on the dial too. Build Dial lets you combine the builtin modes with your agents:

Build Dial with Medium, High, and the Grok 4.6 plugin mode in three slots, one vacant slot, and a catalog of available modes …

When you send a message while the agent is working, it's now delivered at the next possible opportunity, instead of being queued until the agent finishes its turn.

This means the agent acts on your feedback sooner and doesn't waste time on unnecessary verification steps.

Most people won't need to change how they use Amp.

If you do find Amp steering too abruptly, we've found that it works well to phrase your prompts like "When done, then ..." instead of "Now, ...".

Ship, Review, and other builtin actions still queue, because usually you want to wait until the agent is done before shipping or getting a review.

If needed, you can still queue from Amp or queue in the Amp CLI.

Your orb now has a desktop you can see and control.

Use the Desktop tab in any orb thread to get a high-resolution interactive Linux desktop.

It's useful for verifying the agent's work when developing for Linux, Android, or the Chrome extension API, or when working with file formats that need to be opened in desktop applications. It's also useful for computer use, CAD, and anytime you just want a desktop in the cloud.

Modibo Sissoko, an Amp user, sent in a video of how he tests .docx files exported by his application in LibreOffice to make sure they look right:

And if you're curious what Puck does for fun when not helping you, turn on Fun Games in Desktop:

Claude Fable 5.1 now powers Amp's ultra mode, replacing Fable 5.

It's very good at writing, very good at taking direction mid-task, and very good at working on its own. And it costs less to run.

Long Tasks and Proof of Work

What won us over is how much better it got at long horizon work, at giving proof of its work, and at iterating on that proof. It runs for hours on its own, and when the proof doesn't hold up, it goes back and fixes the work, then proves it again.

Some examples:

• Hamish told it key presses felt laggy in our iOS app and asked it to find out why. Two hours later it had a side-by-side video of the old and new builds typing the same sentence on an iPhone simulator. Along the way it caught a two-pixel height difference in its own comparison, corrected it, and re-recorded. Typing latency in Safari went from 85 ms to 8 ms.
• Thorsten recorded his screen creating a new thread on ampcode.com and asked it to make that twice as fast, however long that may take. Fable 5.1 pulled every frame out of the recording to time each step, then found the biggest delay was waiting for the server to finish creating the thread. Creating a thread got 45% faster.

Writing …

The first challenge in code review is figuring out which files to read first. Amp now orders diffs intelligently and highlights which files contain the essential changes.

Click the file order button to toggle between alphabetical and intelligent order. Amp reads the diff, finds the files that best explain the change, and moves them to the top.

The Changes pane with intelligent file ordering enabled, important files first, and less important files muted

Less relevant files, such as tests, fixtures, and generated code, will be shown in muted colors below the important ones.

If the diff changes while you're reviewing it, a blue dot over the button will indicate that there is an updated ordering. Clicking it will update the diff with the new order.

Amp can now use a Git identity that is separate from the email on your Amp account. Pick the name and verified email that should appear on commits made in orbs.

You can ask Puck to set it for you:

Puck setting Tim Culverhouse and tim@culver.house as the personal default Git identity

If you have not added the identity yet, Puck sends a verification link to the email address. Once you click it, Puck gets notified and can make the identity your personal default if you asked it to.

You can also manage identities under Signing Keys. Your personal default applies to personal projects unless you choose another identity in a project's settings. Workspace admins choose one rule for the whole workspace:

• Amp uses the Amp identity.
• Amp Account uses each member's Amp account.
• User Choice lets each member choose.

When Amp starts an orb, it sets GIT_AUTHOR_* and GIT_COMMITTER_* from the selected identity. If commit signing is on, Amp only signs for an email you have verified.

Your Amp login can stay tfc@ampcode.com while your commits use tim@culver.house.

Projects in Amp can now include more than one repository.

Additional repositories are checked out to an adjacent directory in the orb and the agent is made aware of them. The changes panel will show the diff across all repositories in the project.

The Changes panel showing changes in primary and dependency repositories

To add additional repositories, specify them when creating the project or later in project settings. You can add up to 20 additional repositories per project.

The New Project dialog with an arrow pointing to Add Additional Repositories

Only the primary repository's .agents/setup script runs automatically on orb setup. If an additional repository requires initialization, you should update the primary's setup script to include this, or ask an Amp agent to make this update for you.

We are removing the sidebar from the Amp TUI.

Why? Because orbs, runners, and cross-agent messages means that there are more threads than ever. We believe the best place to keep track of all those threads is in the Amp native and web apps, with their more powerful sidebars.

The Amp web app with the sidebar open while several threads run

The TUI is still great at what it does best: local, interactive threads in a single environment. It already comes with its own very powerful multiplexing functionality, complete with tabs, panes, and more; the humble terminal. Adding our own layer of multi-environment multiplexing on top proved to be a less-than-optimal user experience.

But when you need scale, running multiple orbs in parallel, across your team, the best way to manage this complexity is in the web and native app.

---

Perhaps some of you are asking "Why do you keep ripping out the stuff I love?".

Because we believe that this is the best way to use Amp, and the best way to develop software with agents, and we think it's our responsibility to push you in that direction. …

You can now store scripts to set up orbs outside of your repository. Amp can store pre-clone and pre-setup scripts in your project settings and access them when spawning an orb.

The pre-clone setup script gives Amp anything it needs before it clones the repository:

• Install Git extensions that fetch files during checkout.
• Configure certificates for an internal Git server.
• Configure a network proxy needed to reach the Git server.
• Connect the orb to a private network with Tailscale (known issue: use TAILSCALE_API_KEY, OIDC is not yet working with pre-clone scripts).
• Install a credential helper required by the Git server.

Puck working on a request to set up a pre-clone script that installs Git LFS

The pre-setup script lets you work with orbs when you aren't ready to commit setup files to the repository. Amp agents and Puck can access the scripts and set them for you. Give Puck this prompt, or start a thread for the project with this prompt:

An Amp thread starting setup without committing files to the repository

Amp will then inspect the repository and decide which work belongs before or after the clone. It will write and test the scripts, then save them in the project settings.

The scripts are also available on the project settings page, where you can review or edit them by hand.