Amp Code Review

What Amp Code is now

Amp is a coding agent and development environment that can change files, run commands and coordinate work in persistent conversations called threads. You can run it on your own computer or in an Orb, Amp's cloud machine for a thread, then return through the web, terminal or native apps. The product's useful distinction is the environment around the agent: where it works, how you inspect the result and how colleagues join it. Amp's current introduction describes that broader product.

Verified on 12 October 2026: Amp's live documentation, model list, pricing tabs and pricing details, plus the competitors' official pages. This is a documentation-based review with calculated cost examples, not a hands-on coding benchmark. The verdict turns on execution environment, billing boundaries, repeatable setup and team access. The workflows below illustrate documented features; they are not claimed test results.

Who should use Amp, and who should skip it

Amp makes the most sense for developers who can describe a finished result and review the evidence when it comes back. A small team handing work between people, machines and agent threads has a stronger reason to adopt it than a solo developer who only wants help editing the current file.

These are purchase entry points, not equivalent quantities of coding. A subscription price cannot tell you how many accepted changes a particular repository will produce.

Amp vs Claude Code

Claude Code, Anthropic's coding agent, is the cleaner choice when you mainly want to work directly with Claude and already like your terminal or IDE workflow. Its official overview lists terminal, VS Code, JetBrains, desktop and web access. Amp's appeal is the surrounding workspace and execution system, especially when other people need to inspect or continue the same work. Claude Code overview.

That distinction is now more subtle: Amp also offers a Claude Code mode using the Claude Agent SDK and a linked Claude Pro or Max plan. You can therefore choose Amp's environment without choosing Amp's native agent for that thread. The mode has feature differences, covered below; it is not a promise of complete Claude Code parity.

When Codex is the better starting point

OpenAI Codex is the sensible starting point if you already pay for ChatGPT and want to use its included coding access. Plus includes Codex on the web, CLI, IDE extension and iOS, with additional usage available through credits. Amp needs to earn its place through its workspace, runtime or model-routing choices; access to OpenAI models alone is not enough reason to add it. Codex pricing and availability.

Codex also has usage limits. Moving from one subscription to another does not establish which agent will finish your work more cheaply, and this review supplies no invented performance ranking.

For the wider shortlist, see Claude Code alternatives. If your choice has narrowed to the direct vendor tools, the separate Codex vs Claude Code guide covers that pairing.

Where Amp runs: CLI, editors, web and apps

Amp currently runs through the web, its command-line interface and macOS/iOS apps. The CLI supports macOS, Linux and Windows through WSL, the Linux environment available on Windows. It can run work locally, in an Orb or on a connected runner, which is a machine you provide. The native apps let you follow threads on Mac, iPhone and iPad. Introduction and CLI manual.

The editor distinction matters. Amp's own February announcement scheduled the old VS Code and Cursor extensions to end on March 5, 2026, at 8pm Pacific Time. That is a first-party statement, not an inference from a missing download link. Amp's extension retirement announcement.

Today's CLI still connects to VS Code, Cursor, Windsurf, Zed and Neovim. Open the editor, run amp, press Ctrl+O and select ide connect. Amp can see the open file and selection and edit through the IDE with undo support. Neovim additionally needs Amp's Neovim plugin. This is CLI-to-editor integration; the discontinued sidebar extension is a different interface. Current editor connection instructions.

The published installer for Mac, Linux and WSL is:

curl -fsSL https://ampcode.com/install.sh | bash

After installation, amp opens the interactive interface, amp --help lists commands, and amp update checks for updates. These commands are from the manual; they were not used here to run a signed-in coding task.

Choose the interface separately from the execution machine. A browser can control work on your own runner; a terminal can launch work in an Orb. Closing your laptop only leaves the task running if the machine doing the work remains available. That is why cloud Orbs matter more to autonomy than whether the prompt box lives in an editor.

Orbs turn long tasks into work you can leave running

Amp's Orbs give each thread a fresh, isolated remote environment containing its code, development tools and plugins. The agent can install dependencies, run the application, use browsers and test its changes while your laptop is closed. You inspect the conversation, changed files, terminal and running services from the thread. Orbs manual.

Consider an intermittent checkout failure. A useful assignment is not “fix checkout.” It identifies the failing flow, the expected behavior, the tests that must pass and the evidence needed for review. The machine staying alive is valuable because reproduction and verification can continue without your laptop; it does not guarantee that the diagnosis is correct.

The documented CLI can start the same kind of remote investigation:

amp -ox "Investigate why the latest CI run on main failed"

For machines you already maintain, amp --no-tui starts a runner that accepts remotely created threads. This avoids Amp Orb charges, while leaving you responsible for the machine and its availability. Runner documentation.

Puck, Amp's coordinating assistant, can start agents, monitor threads, send follow-up instructions and collect reports. For independent investigations, such as separate failures in unrelated packages, that coordination is useful. Splitting a tightly coupled change across agents can instead create more review work. Delegation pays when the pieces have clear boundaries. Puck's documented capabilities.

The Dial chooses effort, models and specialist help

Amp's Dial offers low, medium, high and ultra, with each mode combining a model, reasoning effort, prompt, tools and an Oracle for second opinions. Choose based on how much the task needs to discover. A known, localized fix and an uncertain migration should not automatically receive the same budget. The Dial.

The live Amp Credits routing lists these main agents:

• Low: GLM-5.3-Flash, high reasoning effort, for small, well-defined tasks.
• Medium: Claude Opus 5.5, high effort, the default for most work.
• High: GPT-6 Astra, medium effort, for difficult tasks where deeper reasoning is worth the wait and cost.
• Ultra: Claude Fable 5.1, high effort, for the hardest open-ended work.

The Oracle is GPT-6 Astra at x-high effort in low, medium and ultra; high uses Claude Fable 5.1 at x-high effort. The displayed task-subagent routing is Claude Opus 5.5 at medium effort. These are the defaults verified for this review, not a permanent model guarantee. Current modes and models.

A practical migration workflow would start with a clear description of the compatibility requirement, then choose medium for a bounded change or a higher mode when the approach itself needs investigation. Ask for tests around the old behavior and a list of incompatible assumptions. Paying for more reasoning is defensible when a subtle missed dependency would invalidate the migration; it is wasteful when the work is a mechanical edit.

The specialist models Amp lists

Amp lists Search on GPT-5.6 Terra, Librarian on GPT-5.6 Sol, Task on Claude Opus 5.5, and Read Thread on GLM-5.3 in the default routing. Search retrieves relevant code; Librarian researches external code; Task performs delegated coding and verification; Read Thread summarizes earlier conversations. Puck is listed on GPT-5.6 Sol. Model list.

Supporting jobs use GPT Transcribe for dictation, GPT Live 1 for realtime voice, Gemini 3.7 Flash for media analysis and GPT Image 2 for Painter image generation/editing. Titling and compaction, which summarizes long conversations, are listed as using the same model as the thread. This is why the model behind the main agent does not describe every model call on the bill.

Linking ChatGPT does not make every call included

Amp can route supported OpenAI usage through a linked ChatGPT subscription. Linking alone does not change which models your modes select. Its ChatGPT Only preset puts the low main agent on GPT-5.6 Terra, medium on GPT-6.1 Sol and high on GPT-6 Astra, with OpenAI routing for their Oracles and task subagents. The public Modes page also shows the subscription-routing view. Subscription routing and preset behavior.

Ultra's Claude Fable main agent is not covered by ChatGPT. Supporting services remain another boundary: Painter, web search, reading web pages and voice can still use Amp credits, and cloud Orbs are separate. Pinning the main agent, Oracle and subagent models does not pin every supporting model. A developer trying to control spend needs to understand the whole thread, not just recognize an OpenAI model name.

Claude Code mode is a distinct option

Amp's Claude Code mode uses a linked Claude Pro or Max subscription through the Claude Agent SDK. The Claude plan does not cover Amp's native medium, high or ultra modes merely because they might use Claude models. This integration was announced on October 10, 2026. Amp's announcement.

That mode supports Orbs, runners, sharing, portals and multiplayer, but excludes Oracle, Librarian and Illustrator. Claude Code's plan mode, todo tool and notebook editing are disabled; Painter still uses Amp credits. Choose it to combine Claude subscription access with Amp's environment, while accepting those differences. Mode limitations.

Repeatable setup matters more than a longer prompt

Amp becomes more useful when a fresh thread can build and check your project without rediscovering its environment. Its Orb lifecycle uses .agents/setup to prepare reusable snapshots and .agents/resume after activation and each wake. A snapshot is a saved prepared machine state, allowing later threads to reuse installed tools and dependencies. Customizing Orbs.

For a web application, put dependency installation and shared prerequisites in setup. Use resume for authentication or connections that need refreshing. Keep the actual build and test commands in AGENTS.md, Amp's repository guidance file, alongside architecture notes and release constraints. Amp also supports directory-specific guidance and falls back to AGENT.md or CLAUDE.md where no AGENTS.md exists. Guidance rules.

The benefit is consistency. A regression investigation should start with the same dependency setup as the next feature task. Otherwise an agent can spend time fixing an environment problem that another thread will encounter again.

There is a concrete maintenance catch: changing .agents/setup does not itself invalidate an existing snapshot. Amp can reuse a matching snapshot for up to 72 hours; delete the cached snapshot in project settings when a setup change must take effect immediately. In projects spanning repositories, only the primary repository's setup script runs, so it must initialize the others. Snapshot lifecycle.

Plugins can add custom modes and subagents for repeated work. Start by making the normal build, test and review path dependable; only then package repeated instructions into specialist agents. A custom reviewer cannot compensate for an acceptance test nobody defined.

Teams get shared work, billing and administration

Amp's team workspace combines shared threads, projects, settings and paid credits without a separate Teams fee. Members can use different individual tiers. That is attractive when a few developers do most of the agent work while colleagues mainly review it. Workspace manual.

The listed team features include thread sharing and permissions; multiplayer; shared portals, plugins and skills; member management, controls and analytics; pooled paid credits; shared provider keys and model routing; and SAML/OIDC single sign-on. A portal exposes a service running in an Orb for inspection. Single sign-on lets people authenticate through the organization's identity provider.

A useful team workflow is a developer handing over a failing integration investigation with its logs, code changes and running environment intact. A colleague can inspect the same thread instead of asking for a copied chat transcript and a separate environment setup. Shared skills and project settings also reduce repeated configuration.

SSO has a qualification: an ordinary workspace needs at least one current member on an active Megawatt or Gigawatt tier. Enterprise workspaces can configure it without a paid member tier. The feature appearing on the Teams card does not make a workspace containing only Hobby members eligible. SSO eligibility.

Enterprise adds custom pricing, SCIM directory synchronization, narrower administrative roles, user groups, per-user quotas, allowed-model controls and MCP registry allowlists. MCP connects agents to external tools and services. The pricing page also lists audit logs, network controls, IP allowlisting, regional endpoints, higher quotas, priority support and custom commercial terms. These requirements, rather than team size alone, are reasons to evaluate Enterprise. Enterprise details.

Shared billing needs one further distinction: paid workspace credits are pooled, but members' Megawatt/Gigawatt Orb minutes are per person. Buying a large allowance for one developer does not create a shared Orb-minute allowance for everyone. Amp states this in the pricing page's Shared Billing Details. Team pricing.

Amp Code pricing: every current tier and the separate usage bill

Amp offers Hobby, the Individual tiers Megawatt and Gigawatt, no-extra-charge Teams and custom Enterprise pricing. The following amounts and allowances were verified on the live pricing page, including its Gigawatt tab and Orb Usage Details, on 12 October 2026.

Source: Amp pricing. Students and teachers can get Megawatt for $10/month, according to the page's Education Discount answer.

Paid tiers include Orb usage and Amp credits for inference, according to the pricing FAQ. The public cards and FAQ do not state a fixed dollar quantity of included model credits, so no invented token budget belongs in a comparison.

The machine size changes how far the allowance goes. Megawatt's published allowance is 90,000 minutes for tiny, 45,000 for small, 22,500 for medium, 11,250 for large and 5,625 for xxlarge. Gigawatt lists 960,000, 480,000, 240,000, 120,000 and 60,000 minutes for those same sizes, plus 37,373 minutes for 3xlarge. The largest size is available only to Gigawatt and Enterprise. These are the pricing page's stated allowances, not a conversion of headline minutes into unlimited parallel compute. Orb Usage Details.

Amp Code free: what Hobby does and does not cover

Hobby has no monthly platform fee. Bring your own runner and supported model subscription or API key, and Amp does not add token fees or limits for Hobby, Individual or Teams. Your provider's charges and limits still apply. Buy inference through Amp or run cloud Orbs and those resources can cost money. Enterprise uses custom terms. Pricing FAQ.

Do not budget around the former daily free-credit program. The original Amp Free announcement now says that program is paused and that Amp does not intend to bring it back. The current free entry point is Hobby; free platform access and free model inference are different things. Amp Free update.

How inference and compute are charged

For individuals and non-enterprise workspaces, Amp says purchased credits pay actual model and tool usage without a markup on providers' API prices. Its own example is $2 of Anthropic usage plus $0.50 of OpenAI usage, deducting $2.50. Non-model tools, including web search, also consume credits. You do not need a paid tier to purchase credits. Usage billing.

The standard published Orb rates are:

• a1.tiny: $0.08/hour, 1 CPU and 2 GB memory.
• a1.small: $0.17/hour, 2 CPUs and 4 GB memory.
• a1.medium: $0.33/hour, 4 CPUs and 8 GB memory.
• a1.large: $0.66/hour, 8 CPUs and 16 GB memory.
• a1.xxlarge: $1.32/hour, 16 CPUs and 32 GB memory.
• a1.3xlarge: $2.13/hour, 16 CPUs and 44 GB memory, for Gigawatt or Enterprise members.

All current sizes include 60 GB of disk. Billing is by the minute; paused Orbs cost nothing. Enterprise Orb pricing is shown in project settings rather than guaranteed by these standard rates. Orb sizes and costs.

Included monthly usage resets at the billing-period boundary and does not roll over. Purchased credits expire twelve months after purchase. When included usage runs out, additional credits can keep work going; Orb usage can also be handled by upgrading. Cancellation leaves a paid tier active until its current monthly period ends. Credit rules and cancellation FAQ.

Calculate accepted outcomes, not tokens alone

A useful cost measure is total model, tool and compute charges, plus allocated subscriptions, divided by the changes you actually accept. Failed attempts belong in the numerator. A long thread is not automatically an expensive failure, and a cheap thread is not a bargain if someone must redo its work.

For a recurring budget, Megawatt plus ChatGPT Plus has a calculated $40/month subscription floor, from $20 plus $20. That floor excludes extra Amp usage and calls outside the linked subscription. An existing Plus subscriber can instead begin with Hobby and their own compute; a second subscription is not required merely to connect the plan. Amp pricing and ChatGPT/Codex pricing.

Upgrade because your measured Orb usage or required machine size justifies it. Do not upgrade simply because the work is autonomous.

Amp's limitations can change the decision

Amp has concrete boundaries that matter more than a generic claim that autonomous agents sometimes make mistakes.

Looking at an Orb can restart its bill

An Orb pauses only after both conditions hold: the agent has done no work for 5 minutes, and there has been no user interaction for 20 minutes. Opening an unarchived thread or portal can wake it. An authorized request to a portal, including from a service, starts a new interaction window. That matters if a preview URL is being polled. Pause rules.

Orb Saver Mode prevents merely opening a thread from waking its machine. Archiving stops it immediately. The idle mechanism is useful, but “the agent finished” and “compute billing stopped” are not always the same moment.

Multiplayer grants environment access, not just conversation access

Amp multiplayer lets workspace members prompt together and access the thread's Orb or shared runner, including files, terminal and secrets. Tagging a colleague activates multiplayer; activating it on a private thread shares that thread with the workspace. All agent and Orb costs remain attributed to the thread owner. Multiplayer manual.

That is useful for colleagues working within the same trust boundary. It is a poor default for inviting someone merely to read a result. Use thread visibility deliberately, and remember that workspace admins can see members' private threads. A user can belong to at most one workspace; that also deserves attention if you work across unrelated clients. Workspace ownership and access.

You cannot raise the mode inside an existing thread

Amp fixes a thread's mode after its first message. If a supposedly small refactor becomes an architectural problem, moving to a higher mode requires a new thread. The manual explains that modes have different prompts and tools, and switching would disrupt model context and caching. Mode selection.

This makes the initial scope consequential. Ask for an investigation before implementation when you do not yet know how large the change is.

Specialist delegation is not a live group conversation

Amp's specialist subagents work in isolation. They cannot communicate with each other, you cannot steer them mid-task, and the main agent receives their final summaries. That is different from separate threads coordinated through Puck or thread-to-thread messaging. Subagent limitations.

Use specialists for bounded work with a clear output. A vague assignment can return a polished summary of the wrong problem, leaving the coordinating agent to discover the mismatch afterward.

Defaults and setup require maintenance

Amp changes its default model routing over time. Model pins help control that, but the manual allows automatic fallback when a pinned model becomes unavailable or restricted. Combined with the snapshot behavior described above, this means neither your model assumptions nor a changed setup script should be treated as automatically fixed forever. Model tuning.

The practical wall is reproducibility: a long-running agent still needs a repository it can build, a task it can finish and evidence a human can evaluate. Amp supplies useful machinery around those requirements; it does not remove them.

Verdict: choose Amp for shared autonomous work

For a solo developer already productive in Claude Code: stay unless Orb execution, shared threads or Amp's model routing solves a specific recurring problem. Using a different interface is not evidence of better coding.

For a ChatGPT subscriber: begin with the Codex access you already have. Amp becomes a stronger choice when its environment and collaboration model are what you need; Hobby and your own runner keep that decision separate from buying an Amp subscription.

For a small team delegating independent tasks: Amp deserves serious consideration. Repeatable Orb setup, shared settings and reviewable threads address the handoff work around coding. Assign paid tiers according to individual compute usage, because Orb minutes are not pooled.

For a team with strict identity, model or access policies: evaluate Enterprise's explicit controls before committing. For a developer who primarily wants an editor sidebar, the old Amp extension is not the product to choose.

The decision rule is straightforward: choose Amp when managing execution and handoffs is a larger problem than your current agent's interface. Before the next task, prepare a reproducible setup, write acceptance checks, identify where each model call will be billed and decide who should access the resulting environment. Those choices determine whether a long autonomous run produces a useful result.

Questions developers ask before choosing Amp

Get the AI business workflow audit checklist through the newsletter to map the work worth delegating, its costs and the checks needed before accepting the result.