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.

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.

In our evals, GPT-6 Sol scores about the same as GPT-5.6 Sol, at half the cost. In real work, though, it's much more jagged: strong on one task, off on the next. medium carries most threads, so it needs a model you can count on across all of them.

When To Turn the Dial Up

medium is the right place for most work now. Two kinds of task still belong higher:

Lots of unknowns. Use ultra with Fable 5.1 when nobody knows the path yet. Alex had to move more than 5,000 users of an enterprise customer's SSO to new email addresses. He started the thread with:

We've never migrated… from one set of email addresses to the next before… and we don't really have a way to test it.

It mapped how sign-in works today, planned the switch, and watched production afterward. The first 41 sign-ins after the switch all worked.

Taste and judgment. Use high with GPT-6 Astra or ultra with Fable 5.1 when the hard part is deciding what good looks like. Ask for options, not one answer. Hamish wanted a better transition out of the iOS image viewer:

Right now it's a hard cut, so can you please give me some options for animations and record them and show me them in line in the transcript here.

It recorded four options on the simulator. He replied "Ship B to main."

Turn the dial up when a miss costs more than the wait, not because the task is long.

How To Use It

Opus 5.5 is persistent. It keeps going until the job is done, which means it needs to know what done is, and it needs a way to see for itself. These are the habits we use, with prompts from our own threads:

Give it the whole app to run. Models are very good at writing tests their own code passes. Running the app end to end is the best way to know it works. Make that one command with .agents/setup, services, and a skill. Tim hit a sidebar bug in our Mac app and asked:

Repro it in preflight then we can look at fixing it.

It launched our Mac app, dragged the sidebar closed, and measured the bug before touching any code.

Tell it what done looks like, including the evidence it should deliver. Our bug fix prompts include:

Implement the simplest correct fix, verify it, then explain the bug, the fix, and the evidence that the fix resolves it.

That evidence is usually a failing test plus before and after videos.

Raise the bar when the check is too easy. If it verified against an emulator or a mock, send it to the real thing. When it checked an iPad fix in an emulator, Quinn replied:

test all of this in the Buildkite iOS preflight and use an iPad simulator

The simulator caught two bugs the emulator had missed.

Hand it the bigger task and go hands off. It holds up well over long threads. Tell it what evidence to deliver, then go do something else. You shouldn't babysit a capable model: if you have the patience to watch it work step by step, you're giving it too short a leash.

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.

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.

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.

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.

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.

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.)

Workspace admins can turn off runner sharing in Member Settings.

Read more about sharing a runner 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.

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 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 thread that runs in a worktree the runner created gets a new action: Archive and Remove Worktree. It archives the thread, runs git worktree remove, and deletes the branch.

New Folders and Projects Too

The picker can also create things. Type the name of a directory that doesn't exist yet and you get New Directory or New Project. Read more.

Oh, They Understand Secrets Now Too

Runners can also use the Secrets & Env Vars you configure on ampcode.com. Same variables that orbs get. It's off by default; opt in with --amp-env:

$ amp --no-tui --runner-id mac-mini --discover-dirs --amp-env

Every time a thread starts, the runner fetches the variables that apply to it (personal, then project, then workspace) and adds them to the environment of the thread's shell commands, MCP servers, and plugins. Change a variable on ampcode.com and the next thread gets the new value. No restart, no SSH.

Both need a runner on the current Amp version. If yours has been running for a while, it has updated itself already.

Read more about worktrees and Secrets & Env Vars in the runner docs.

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.

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.

Oh, They Can Update Themselves Too

Runners now update themselves too. If you leave an amp --no-tui runner running, it keeps checking for new releases about once an hour and installs them. Once no thread is running on it, it restarts into the new version, at most once every 12 hours. It keeps its runner ID, its directories, and the rest of its flags.

Turn it off with amp.runner.autoUpdate.enabled: false in your settings.

Read more about serving multiple directories and runner updates in the runner docs.

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.

Now, you can invite everyone to your Amp workspace for free and feel the magic of Amp's shared threads, shared portals, and multiplayer.

Everyone can use Amp with ChatGPT subs or your company's preferred AI gateway via BYOK, with no monthly fees.

Power users can upgrade to paid tiers for big orb discounts, while everyone else in the workspace can remain on the free Hobby tier and consume your pooled workspace credits for orbs pay-as-you-go.

Also, you get free SAML/OIDC SSO for the whole workspace if at least one member is on a paid tier.

Finally, we're now formally extending our zero and minimal data retention policy to all Amp users and workspaces, not just to our Enterprise tier. (Everyone was always covered by it for all Amp usage since we started, but until now we could only contractually guarantee that to our Enterprise customers.)

One More Thing: More BYOK Options

Update (September 30, 2026): These are now available to all Amp users on every tier. Set them up in Model Routing. Thank you so much to our Megawatt and Gigawatt members who got early access and gave us valuable feedback!

Today, Amp Megawatt and Gigawatt members are also getting early access to more BYOK providers:

• OpenRouter
• Amazon Bedrock
• Google Cloud Agent Platform (f/k/a Vertex AI)
• Azure Foundry
• Vercel AI Gateway
• Cloudflare AI Gateway
• Ollama Cloud
• OpenCode Go
• Custom endpoint URLs

To try these, configure them in Model Routing in personal settings or workspace settings.

Tune Your Modes

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.

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.

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:

• Keep medium and high for building, and add a reviewer with your team's review instructions.
• A plugin agent can extend a builtin mode, so you only need to describe what it should do differently.
• Drag two to four modes onto the dial, put them in order, and hold to save.
• Use the mode picker in the app or press Ctrl+S in the CLI to switch between them.
• Workspace admins can set a shared dial too.
• Your personal choices take precedence.

Make the dial yours. The docs cover both tabs.

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

Writing is where it impressed us the most. So far we haven't been big fans of using AI for prose. Fable 5.1 changed that. The text it produces reads more like it was written by a person. It explains the idea behind a change instead of every technical detail, and draws a diagram when that's clearer than a paragraph. We ended up using it for our new docs pages, where it not only surprised us by writing concise prose but also by running the features on a dev server, executing them end to end, and documenting them with screenshots and demo videos.

Steering

We steer it a lot more now. Fable 5 would sometimes ignore an instruction sent mid-task and carry on with the work it already had. Fable 5.1 does both: it finishes the original task, does what you just asked, and reports on each separately. It addresses every instruction you give it, even several at once. It works great with the Steer, Not Queue setting turned on.

Cheaper

And it costs less: ultra threads are about 35% cheaper than before. Cache reads are 75% cheaper than on Fable 5, and in a typical Amp thread, over 90% of tokens are cache reads.

How To Use It

ultra is for the work where the outcome is clear and the path is not. Fable 5.1 is at its best there. A few habits help:

Tell it what done looks like, and how to prove it. Example: "The sidebar stutters when scrolling through a few hundred threads. Find out why and fix it. Show me a video of scrolling before and after on the same thread list, and frame times measured in Safari, not Chrome."

Steer it while it works. If it's heading somewhere you don't want, say so in the moment. You can also hand it new tasks while it's busy; it addresses all of them without dropping the one it's on.

What the Team Says

Very impressed by Fable 5.1. It's very good at writing, it's very good at... everything really? I'm in a thread where I constantly reply to 2-3 different things and it perfectly keeps them apart. It's like having two conversations at once.

— Thorsten Ball

I've also been impressed with Fable 5.1. Feels less hand-wringy than Fable did.

— Camden Cheek

In my code reviews I agree with its changes more than I agree with the previous Fable's. And I steer it a lot more, because it handles multiple requests at once.

— Hitesh Sagtani

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.

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.

Every thread in Amp now comes with its own space to talk.

Hit Enter and you're in. Turn on your camera, share your screen, and talk it over with your team while the agent works.

No links to paste, no calendar invite, no other app. The call lives where the work lives.

In the future, we see the space becoming a place to talk freely, alone or with others: brainstorm, whiteboard, talk with Puck or other agents, discuss the thread or spawn new ones... who knows?

We're leaving it open. For now, it's just a space. What you do with it is up to you.