# Amp: features, protocols, quickstart

## TL;DR

Amp is a proprietary coding agent available on the web, as a CLI, and in macOS and iOS apps. For multi-agent work it has specialist subagents, orbs (a fresh remote machine per thread), agent-to-agent delegation between threads, and Puck, an assistant that starts and coordinates agents. It suits developers who want several remote agent threads running at once.

## Key facts

| Field | Value |
| --- | --- |
| Type | Platform |
| Languages / SDKs | TypeScript, Python |
| License | Proprietary |
| Pricing model | [Hosted, paid](https://ampcode.com/pricing) |
| Orchestration pattern | Supervisor |
| Repository | No public repository (closed source) |
| Website | [ampcode.com](https://ampcode.com) |
| Documentation | [ampcode.com](https://ampcode.com/docs) |
| Last verified | 2026-09-30 |

## Key features

- Orbs are remote machines Amp creates per thread with your code, tools and plugins; several independent tasks can run at once and the agent keeps working when your laptop is closed. ([source](https://ampcode.com/docs/orbs))
- Agent to Agent lets an agent start other agents (in an orb, another project or a runner), send them instructions and files, and bring results back into the current thread; the docs show four-way parallel fan-out. ([source](https://ampcode.com/docs/orbs/agent-to-agent))
- Specialist subagents (Search, Oracle, Librarian, Read Thread) each get their own context window and return only a final summary; plugins can define custom subagents. ([source](https://ampcode.com/docs/models-and-subagents))
- Puck is a personal assistant that starts agents in projects, sends them further instructions, tracks them and brings results back, including from Slack. ([source](https://ampcode.com/docs/puck))
- `amp -ox` starts an execute-mode prompt in an orb and returns a thread URL immediately; `amp --no-tui` turns a machine you own into a runner for remotely started threads. ([source](https://ampcode.com/docs/cli/spawning-orbs))
- Plugins can expose webhooks that wake an orb when an external service such as GitHub sends an event, and automations run Amp on a schedule. ([source](https://ampcode.com/docs/orbs/event-driven))
- Multiplayer lets several people prompt the same thread and its orb, and workspaces add shared threads and pooled billing. ([source](https://ampcode.com/docs/collaborate/multiplayer))
- A TypeScript and Python SDK and a streaming JSON CLI mode let other programs drive the Amp agent. ([source](https://ampcode.com/docs/sdk))

## Architecture and orchestration pattern

Pattern: Supervisor.

Amp is a hosted agent product with clients on the web, terminal and Apple platforms, all showing the same threads. A thread is a conversation with one agent, in one of four modes (low, medium, high, ultra) fixed at the first message. The agent can run on your machine, in an orb, or on a connected runner. An orb is a remote machine created for that thread; it sleeps when idle and wakes with the conversation, files and services in place.

There are two levels of delegation. Subagents are specialists inside one thread: they work in isolation, cannot talk to each other, cannot be steered mid-task, start with only the context the main agent gives them, and return a final summary. Agent to Agent goes further: an agent starts a new thread with its own conversation, context window, working copy and orb, exchanges files by explicit transfer, and gets the result back. Puck sits above threads as an assistant that starts and monitors agents across projects.

State is the thread (conversation, changes, running services) plus project settings, secrets and plugins. Threads do not share uncommitted files automatically. The docs advise keeping work in one thread when tasks need constant coordination or edit the same files.

### Human in the loop

By default Amp does not ask for approval before running tools; the docs point to custom plugins for permission control, with an example plugin that asks the user before risky git commands. Users can queue a message, press Esc twice to interrupt the agent, review the diff in the thread's changes view, and use the terminal pane in an orb. MCP servers can be allowed or blocked by pattern rules. Subagents cannot be guided mid-task. Workspace members can prompt the same thread together with Multiplayer.

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://ampcode.com/docs/customize/mcp) | Client: local and remote MCP servers are added with `amp mcp add` or the `amp.mcpServers` setting, and can be bundled inside skills. No MCP server of its own is described on that page. |
| A2A | Unknown (checked 2026-09-30) | — | No mention of the A2A protocol in the 49 Amp docs pages fetched from ampcode.com/llms.txt. The docs have an 'Agent to Agent' page, but it describes Amp's own delegation between threads and does not name the A2A protocol. |
| AG-UI | Unknown (checked 2026-09-30) | — | No mention of AG-UI in the Amp docs pages fetched, and Amp is not listed in the AG-UI protocol README. |

## Best for

- Developers who want to start several independent tasks at once in remote orbs and check on them from a phone, Mac or terminal. ([shortlist](https://multiagentguide.top/best/parallel-coding-agents.md))
- Delegating side quests or fan-out work (for example the same test at four screen sizes) from one thread to others and collecting the results. ([shortlist](https://multiagentguide.top/best/coding-agents.md))
- Event- or schedule-driven agent runs through plugin webhooks and automations.

## Not for

- Teams that need an approval prompt before every tool call out of the box; the docs say Amp does not ask by default.
- People who want a stable, backward-compatible tool: the introduction says Amp goes where the models take it, with no backward compatibility or legacy features.
- Anyone who needs open-source code or a self-hosted control plane; Amp is proprietary and its orbs run on Amp's servers (your own machines can act as runners).

## Quickstart

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

Install not yet verified by this site.

```bash
# Install the CLI (macOS, Linux, Windows via WSL), then sign in and start it
curl -fsSL https://ampcode.com/install.sh | bash
amp login
amp

# Pipe a first message into interactive mode
echo "commit all my changes" | amp

# Run a prompt in a remote orb; it prints a thread URL and exits
amp -ox "Investigate why the latest CI run on main failed"

# Turn this machine into a runner for threads started from ampcode.com
amp --no-tui --runner-id my-dev-box

# Add an MCP server
amp mcp add context7 -- npx -y @upstash/context7-mcp
```

### Common pitfalls

- The CLI supports macOS, Linux and Windows through WSL; the docs recommend WezTerm or Alacritty over Windows Terminal for clipboard support.
- A thread's mode (low, medium, high, ultra) is fixed at the first message; start a new thread to change it.
- Each user can start a burst of 20 metered orbs, then one new orb every five minutes; later starts wait instead of failing.
- Orbs have their own usage allowance billed by the minute and pause after the agent stops; included usage does not roll over, and purchased credits expire twelve months after purchase.
- Threads do not share uncommitted files automatically; ask Amp to transfer files between agents.
- The CLI was rebuilt in May 2026 (Amp Neo) and the npm package is now `@ampcode/cli`; older SDK releases are pinned separately in the SDK docs.
- Tools run without approval by default.

Official quickstart: https://ampcode.com/docs/cli

## Pros

- Orbs give each thread an isolated machine, so several tasks can run at once without using your computer, and idle orbs cost nothing. ([source](https://ampcode.com/docs/orbs))
- Agent-to-agent delegation is documented with concrete patterns: side quests, parallel fan-out, file exchange and delegation across projects or machines. ([source](https://ampcode.com/docs/orbs/agent-to-agent))
- Your own machines can serve as runners, and the Hobby tier lets you use your own runners for free. ([source](https://ampcode.com/pricing))
- Supports bring-your-own keys and subscriptions, and the pricing docs say Amp adds no markup to provider API prices for individuals and non-enterprise workspaces. ([source](https://ampcode.com/docs/pricing))
- Extensible with plugins, skills, MCP servers and an SDK for TypeScript and Python. ([source](https://ampcode.com/docs/sdk))

## Cons

- Proprietary, and the introduction says there is no backward compatibility or legacy support, so behaviour can change quickly. ([source](https://ampcode.com/docs))
- Tools run without asking for approval by default; permission control needs a custom plugin. ([source](https://ampcode.com/docs/tools))
- Subagents work in isolation: they cannot communicate with each other, cannot be guided mid-task, and return only a summary. ([source](https://ampcode.com/docs/models-and-subagents))
- Separate threads and orbs have separate workspaces; messages do not transfer files or commits, so files must be sent explicitly, and the docs advise one thread when agents edit the same files. ([source](https://ampcode.com/docs/orbs/agent-to-agent))
- Orb starts are paced (burst of 20, then one every five minutes per user) and a thread's mode cannot be changed after the first message. ([source](https://ampcode.com/docs/orbs))

## Alternatives

- [Conductor](https://multiagentguide.top/tools/conductor.md)
- [Cursor](https://multiagentguide.top/tools/cursor.md)
- [Devin](https://multiagentguide.top/tools/devin.md)
- [Claude Code](https://multiagentguide.top/tools/claude-code.md)
- [OpenCode](https://multiagentguide.top/tools/opencode.md)

## FAQ

### Does Amp support MCP?

Yes, as a client. You can add local or remote MCP servers with `amp mcp add`, in the `amp.mcpServers` setting, or bundled inside skills. Enterprise workspaces can restrict servers with an allowlist.

### Does Amp support the A2A protocol?

Unknown. Amp documents its own Agent to Agent feature for delegating between Amp threads, but the docs pages read do not mention the A2A protocol.

### How much does Amp cost?

The pricing page (read 2026-09-30) lists a free Hobby tier with pay-as-you-go orbs and free use of your own runners, an Individual tier at $20 per month, Teams at no extra charge on top of member tiers, and custom Enterprise pricing. Credits for model use beyond a tier are paid at provider prices without markup for non-enterprise users.

### How do orbs differ from subagents?

A subagent is a specialist inside one thread with its own context window. An orb is a separate remote machine for a whole thread, and agents in different orbs can delegate to each other through Agent to Agent.

## Sources

- [Amp home](https://ampcode.com)
- [Amp docs home](https://ampcode.com/docs)
- [Amp pricing](https://ampcode.com/pricing)
- [Amp docs: Pricing](https://ampcode.com/docs/pricing)
- [Amp docs: Orbs](https://ampcode.com/docs/orbs)
- [Amp docs: Agent to Agent](https://ampcode.com/docs/orbs/agent-to-agent)
- [Amp docs: Modes and models (subagents)](https://ampcode.com/docs/models-and-subagents)
- [Amp docs: Puck](https://ampcode.com/docs/puck)
- [Amp docs: Spawning orbs from the CLI](https://ampcode.com/docs/cli/spawning-orbs)
- [Amp docs: Event-driven orbs](https://ampcode.com/docs/orbs/event-driven)
- [Amp docs: Multiplayer](https://ampcode.com/docs/collaborate/multiplayer)
- [Amp docs: SDK overview](https://ampcode.com/docs/sdk)
- [Amp docs: MCP](https://ampcode.com/docs/customize/mcp)
- [Amp docs: Tools](https://ampcode.com/docs/tools)
- [Amp docs: CLI getting started](https://ampcode.com/docs/cli)
- [Amp docs index (llms.txt)](https://ampcode.com/llms.txt)
- [Amp news (CLI rebuilt May 2026, npm package rename)](https://ampcode.com/news)

## Unknown fields

A2A and AG-UI: searched the 49 Amp docs pages listed in llms.txt (fetched as Markdown) for A2A, Agent2Agent and AG-UI and found nothing. Amp has an 'Agent to Agent' feature that is its own delegation mechanism, not evidence of the A2A protocol. Maintainer: the official pages read do not state which company operates Amp (the site lists Sourcegraph only in a logo list, and a news post says the npm package was renamed from @sourcegraph/amp to @ampcode/cli), so the record does not name a company. Pricing: on the pricing page the Individual tier ($20 per month, Megawatt) and Hobby (free) were readable; the price of the Gigawatt tier and per-tier orb-minute allowances were not clearly tied to tiers in the page text, so they are not stated. The pricing docs page renders its tiers with a component that is empty in the Markdown export. Python SDK install command was not read; the TypeScript SDK is `npm install @ampcode/sdk`.

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-09-30. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/amp