# Como usar o Amp: guia passo a passo da CLI do Amp

URL: https://agentvera.dev/pt/blog/how-to-use-amp/ · Publicado: 2026-10-29

Como usar o Amp, o agente de código: instale a CLI, faça login, escolha um modo no Dial e configure AGENTS.md, servidores MCP, subagentes e créditos.

**Resumo:**

- Instale a CLI do Amp com um único comando curl (macOS, Linux, Windows via WSL), rode amp login e depois amp dentro de um projeto. Cada conversa é um thread salvo no ampcode.com.
- Em vez de um modelo, você escolhe um modo no Dial: low, medium, high ou ultra. Escolha com Ctrl+S antes da primeira mensagem, porque o thread mantém o modo.
- As regras do projeto ficam no AGENTS.md; configurações e servidores MCP, em ~/.config/amp/settings.json ou .amp/settings.json. O Hobby é grátis; o uso de modelos sai das suas assinaturas, chaves ou créditos.

Para usar o Amp, você instala a CLI com `curl -fsSL https://ampcode.com/install.sh | bash`, faz login com `amp login`, roda `amp` dentro de um projeto e descreve o que quer. Antes da primeira mensagem, escolhe um modo no Dial com Ctrl+S: `low`, `medium`, `high` ou `ultra`. A partir daí o Amp lê seu código, edita arquivos e roda comandos, e a conversa inteira fica salva como um thread que você pode reabrir ou compartilhar.

Esse é o ciclo básico. Este guia cobre o resto: login para scripts e CI, os atalhos do dia a dia, os modos, subagentes como o oracle, `settings.json`, `AGENTS.md`, servidores MCP, o modo execute, quanto o Amp custa e como rodá-lo ao lado de outros agentes de CLI. Tudo aqui se baseia na documentação oficial do Amp em outubro de 2026.

## O que é o Amp

O Amp é um [agente de código](/pt/glossary/coding-agent/ "O que é um agente de código") e um ambiente de desenvolvimento. Ele nasceu dentro da Sourcegraph e, desde a cisão em dezembro de 2025, é desenvolvido por uma empresa independente. Não fica preso a um único fornecedor de modelos: o Amp escolhe o modelo conforme o modo que você seleciona e pode usar sua assinatura do ChatGPT, sua assinatura do Claude (no modo Claude Code) ou suas próprias chaves de API.

Dá para usar em três lugares: o app web em ampcode.com (sem instalar nada), os apps para macOS, iPhone, iPad e Android, e a CLI no terminal, que é o tema deste guia. Cada conversa é um **thread** com URL própria. O Amp também pode rodar um thread em um **orb**, uma máquina que o Amp cria para aquele thread nos servidores dele, ou em um runner que você mesmo hospeda.

## Passo 1: instale a CLI

| Plataforma | Comando |
| --- | --- |
| macOS, Linux | `curl -fsSL https://ampcode.com/install.sh \| bash` |
| Windows | Rode o mesmo comando dentro do WSL |

A CLI funciona no macOS, no Linux e no Windows via WSL. No Windows, a documentação recomenda WezTerm ou Alacritty em vez do Windows Terminal, porque a área de transferência funciona melhor neles. A página de instalação também tem abas para Windows e Homebrew.

O Amp se atualiza sozinho em segundo plano. `amp update` atualiza manualmente, `amp version` mostra a versão instalada e `amp --help` lista todos os comandos. O autocompletar do shell é uma linha, por exemplo `source <(amp completions zsh)` (bash e pwsh também funcionam; no fish, `amp completions fish | source`).

## Passo 2: faça login

```bash
amp login
```

`amp login` abre o navegador e adiciona uma conta. A CLI pode guardar várias: `amp account list` mostra todas, `amp account switch <email-or-user-id>` escolhe a que os próximos comandos vão usar e `amp logout` remove a conta ativa (`--all` remove todas).

Para scripts, CI e máquinas sem navegador, use um token de acesso:

```bash
export AMP_API_KEY=sgamp_your-token-here
```

O token é criado nas configurações do ampcode.com e começa com `sgamp_`. O token de sessão que o `amp login` guarda expira em menos de uma hora e não pode ser renovado, por isso a CLI não o aceita nesse lugar.

Duas vinculações opcionais mudam quem paga o uso de modelos:

- **Assinatura do ChatGPT:** `amp config model-providers add-chatgpt-subscription` (ou o atalho `amp add-chatgpt-sub`) vincula um plano do ChatGPT, e o uso de modelos da OpenAI passa a sair dele.
- **Assinatura do Claude:** só funciona no modo **Claude Code** do Amp, escolhido no Dial. Os modos próprios do Amp nunca consomem seu plano do Claude.

## Passo 3: o básico da CLI

Rode `amp` em um projeto e digite. Entrada via pipe vira a primeira mensagem, então `echo "commit all my changes" | amp` também funciona. O atalho que você mais vai usar é **Ctrl+O**, que abre a paleta de comandos.

| Atalho | O que faz |
| --- | --- |
| `Ctrl+O` | Abre a paleta de comandos |
| `Ctrl+S` | Gira o Dial (antes da primeira mensagem) |
| `@` | Menciona um arquivo |
| `Ctrl+V` | Cola uma imagem, inclusive no macOS |
| `Ctrl+G` | Escreve o prompt no `$EDITOR` |
| `Ctrl+R` | Abre o histórico de prompts |
| `Esc Esc` | Interrompe o agente |
| `Ctrl+C Ctrl+N` | Arquiva o thread e começa um novo |
| `Ctrl+C Ctrl+C` | Sai |

Se você digitar enquanto o Amp trabalha, o Enter **redireciona** o agente: sua mensagem chega depois do passo atual, sem esperar o turno inteiro acabar. Para enfileirar uma mensagem até o agente terminar, rode `prompt: queue message` na paleta. Shift+Enter insere uma quebra de linha nos terminais que suportam; Ctrl+J funciona em todos. No tmux, rode `tmux set -s extended-keys on` para o Shift+Enter funcionar.

Na paleta, `ide connect` liga o Amp ao VS Code, Cursor, Windsurf, Zed ou Neovim (o Neovim precisa de um plugin). `amp config keymap` lista todos os atalhos.

## Passo 4: escolha um modo no Dial

O Amp não pede um modelo, pede um modo. Cada modo combina modelo, esforço de raciocínio, prompt de sistema e ferramentas, ajustados para um nível de dificuldade:

| Modo | Para quê |
| --- | --- |
| `low` | Mudanças pequenas e bem definidas |
| `medium` | A maior parte do trabalho; a recomendação padrão da documentação |
| `high` | Problemas difíceis ou sutis |
| `ultra` | Trabalho em aberto, como migrações e arquitetura |

Aperte **Ctrl+S antes da primeira mensagem** para girar o Dial, ou abra a paleta e digite `mode`. O thread mantém o modo com que começou; se escolheu errado, abra um thread novo em vez de brigar com ele. Começar alto demais desperdiça tempo e créditos numa mudança simples; começar baixo demais pode sair mais caro se você precisar de várias tentativas.

Se quiser controlar os modelos, em Configurações → Mode Dial → Tune Modes você fixa modelos por modo e pode usar suas próprias chaves de API. Se você prefere escolher um modelo exato a cada sessão, um agente multiprovedor como o opencode combina mais com esse hábito.

## Passo 5: subagentes, o oracle e o librarian

O Amp pode passar trabalho focado para [subagentes](/pt/glossary/subagent/ "O que é um subagente"), cada um com sua própria janela de contexto:

- **Task** faz o trabalho delegado do começo ao fim e devolve o resultado. Pode editar arquivos e rodar comandos, e tem skills somente leitura para buscar no seu código, pesquisar outro repositório, revisar uma mudança e planejar.
- **Read Thread** lê e resume outros threads do Amp.

Os dois usam o mesmo modelo do thread que os iniciou. O Amp recorre a eles sozinho quando o trabalho pede, principalmente no modo `medium`, e você também pode pedir diretamente: “divida isso entre subagentes”.

O oracle (um revisor que nunca edita arquivos), o librarian (que clona outros repositórios em `/tmp` e os explica) e o finder (busca rápida de código) agora fazem parte do Task. Para rodá-los como ferramentas separadas num modelo que você escolher, instale-os como plugins:

```bash
amp plugins add @amp/oracle
amp plugins add @amp/librarian
amp plugins add @amp/finder
```

## Passo 6: configurações

O Amp lê dois arquivos de configuração, e os valores do workspace prevalecem:

- **Usuário:** `~/.config/amp/settings.json` (ou `.jsonc`).
- **Workspace:** `.amp/settings.json` no projeto.

`amp config edit` abre o arquivo do usuário e `amp config edit --workspace` abre o do projeto. Toda chave começa com `amp.`:

```json
{
  "$schema": "https://ampcode.com/cli-settings.schema.json",
  "amp.showCosts": true,
  "amp.git.commit.coauthor.enabled": true,
  "amp.notifications.enabled": true
}
```

- `amp.showCosts` mostra quanto custa cada thread.
- `amp.tools.disable` desliga ferramentas pelo nome, com curingas `*`; `amp tools list` lista as nativas.
- `amp.git.commit.ampThread.enabled` e `amp.git.commit.coauthor.enabled` controlam o que o Amp acrescenta às mensagens de commit, como o trailer `Amp-Thread-ID`, que liga um commit ao seu thread.

Uma coisa para saber antes de começar: por padrão, **o Amp não pede aprovação antes de executar ferramentas**. Trabalhe numa branch, faça commits com frequência e use `amp.tools.disable` ou um plugin se quiser limites. Se você quer um agente que pergunte antes por padrão, o Claude Code e o Codex CLI foram pensados em torno de pedidos de aprovação.

As skills funcionam como em outros agentes: uma pasta com um `SKILL.md`. O Amp carrega skills do projeto de `.agents/skills/`, as pessoais de `~/.config/amp/skills/` e `~/.config/agents/skills/`, e também as pastas do Claude Code `.claude/skills/` e `~/.claude/skills/`.

## Passo 7: AGENTS.md

O `AGENTS.md` guarda as regras de um projeto: como compilar, testar e rodar o linter, quais convenções seguir, quais pastas não mexer. O Amp lê o da pasta atual e o de cada pasta acima até a sua pasta pessoal, e sempre os inclui. Um `AGENTS.md` numa subpasta entra quando o Amp lê um arquivo dali. Se o projeto não tem nenhum, o Amp se oferece para escrever um.

```markdown
# Project rules

- Package manager: pnpm. Run `pnpm test` before you finish a task.
- TypeScript strict mode; no `any` in new code.
- API handlers live in src/api/; one file per route.
- See @docs/architecture.md for the module layout.
```

Alguns detalhes que valem a pena:

- **Menções com @** puxam outros arquivos: caminhos relativos, caminhos `@~/` e padrões como `@docs/*.md`.
- **Regras pessoais** ficam em `~/.config/amp/AGENTS.md` (ou `~/.config/AGENTS.md`).
- **Alternativa:** numa pasta sem `AGENTS.md`, o Amp lê `AGENT.md` ou `CLAUDE.md`, então um projeto do Claude Code funciona desde o primeiro dia.
- **Regras com escopo:** um arquivo mencionado pode ter `globs:` no front matter, para que as orientações valham só quando o Amp trabalha em arquivos correspondentes.

O que colocar no arquivo está em [como escrever CLAUDE.md e AGENTS.md](/pt/blog/claude-md-agents-md/ "Como escrever CLAUDE.md e AGENTS.md").

## Passo 8: servidores MCP

[Servidores MCP](/pt/blog/what-is-mcp-server/ "O que é um servidor MCP") dão novas ferramentas ao Amp: um navegador, um rastreador de issues, busca em documentação. O jeito mais rápido de adicionar um é pela CLI:

```bash
amp mcp add context7 -- npx -y @upstash/context7-mcp
amp mcp add linear https://mcp.linear.app/sse
```

Os dois vão parar nas suas configurações, em `amp.mcpServers`. Um servidor local é um comando, um remoto é uma URL, e `${VAR}` puxa valores do ambiente:

```json
{
  "amp.mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--headless"]
    },
    "linear": {
      "url": "https://mcp.linear.app/sse"
    }
  }
}
```

Servidores definidos no `.amp/settings.json` de um workspace só rodam depois que você os aprova com `amp mcp approve <name>`; `amp mcp doctor` mostra o estado de cada servidor. Quando o mesmo servidor está definido em vários lugares, `--mcp-config` vence o arquivo do workspace, que vence as configurações do usuário. Como cada servidor adiciona suas ferramentas ao contexto, a documentação sugere colocar servidores pouco usados dentro de uma skill (com um `mcp.json`), para que as ferramentas só carreguem junto com a skill.

## Passo 9: threads e modo execute

Cada thread tem uma URL como `https://ampcode.com/threads/T-…`. `amp threads continue T-…` retoma um thread no terminal, `amp threads share T-… --visibility unlisted` o torna compartilhável, e digitar `@T-…` num prompt traz outro thread como contexto. Threads iniciados fora de um workspace são privados.

Para scripts e CI, o **modo execute** roda um prompt e encerra:

```bash
amp -x "what package manager is used here?"
git diff | amp -x "review this diff for bugs"
amp -ox "Investigate why the latest CI run on main failed"
```

`-x` roda na sua máquina e liga sozinho quando a saída é redirecionada. `-ox` roda o prompt num orb. `--stream-json` gera saída legível por máquina, e `--mcp-config` adiciona servidores MCP só para aquela execução.

## Quanto custa o Amp (em outubro de 2026)

| Plano | Preço | O que inclui |
| --- | --- | --- |
| Hobby | Grátis | Todos os recursos do produto; orbs pagos por uso; suas assinaturas ou chaves |
| Individual (Megawatt) | 20 dólares por mês | Uso incluído mais 45.000 minutos de orbs nos servidores do Amp |
| Teams | Sem custo extra | Threads, skills e cobrança compartilhados, créditos em conjunto, SSO |
| Enterprise | Sob consulta | Controles de admin, logs de auditoria, opções de retenção de dados |

O uso de modelos sai de uma de três fontes: uma assinatura do ChatGPT ou do Claude vinculada, suas próprias chaves de API ou créditos do Amp. Quando o uso incluído acaba, você adiciona créditos, e o Amp cobra pelo custo real de modelos e ferramentas de cada thread, sem margem sobre os preços de API dos provedores para pessoas físicas e workspaces que não são enterprise. Não é preciso ter um plano pago para comprar créditos. A busca na web também consome créditos. Os créditos expiram doze meses após a compra, e `amp usage` mostra o saldo. Orbs são cobrados por minuto e pausam quando ficam ociosos; runners na sua própria máquina são grátis.

## Erros comuns

- **Modo errado, e o Ctrl+S não muda.** O thread já tem uma primeira mensagem. Comece outro com Ctrl+C Ctrl+N.
- **A CI diz que o login é inválido.** O token de sessão do `amp login` dura pouco. Coloque em `AMP_API_KEY` um token de acesso `sgamp_`.
- **Um servidor MCP do workspace nunca aparece.** Ele precisa de aprovação: `amp mcp approve <name>` e depois confira com `amp mcp doctor`.
- **Seu plano do Claude não está sendo usado.** Só o modo Claude Code o consome; de `low` a `ultra`, vale o roteamento próprio do Amp.
- **O Amp rodou um comando inesperado.** Por padrão ele não pergunta. Desligue a ferramenta ou trabalhe numa branch descartável.
- **No tmux, Shift+Enter envia o prompt.** Ative `extended-keys` ou use Ctrl+J.

## Rodando o Amp ao lado de outras CLIs no AgentVera

O Amp tem seu próprio app web, app desktop e orbs, e se ele é o único agente que você usa, isso pode bastar. Fica mais difícil quando o Amp roda ao lado do Claude Code, do Codex ou do Gemini CLI no mesmo projeto. O AgentVera é um app desktop que roda essas CLIs lado a lado em terminais reais, com as suas próprias instalações e logins. O [suporte ao Amp](/pt/agents/amp/ "Amp no AgentVera") funciona assim:

- **Seu login do Amp.** O Amp usa o próprio login do ampcode.com; se você estiver desconectado, o terminal do agente pede login na primeira execução. Em Configurações → Contas → Contas de outros agentes você pode adicionar mais contas do Amp, que rodam com chaves de API, e dar a cada agente uma lista ordenada de contas reserva.
- **Um thread por agente.** Um thread novo é criado com antecedência para cada agente com `amp threads new`, e o agente volta a ele com `threads continue` nas próximas execuções.
- **Modos, não modelos.** Você escolhe low, medium, high ou ultra para cada agente, passado com `--mode`.
- **MCP e o navegador.** Os servidores que você adiciona no [gerenciador de MCP](/pt/features/mcp-manager/ "Gerenciador de MCP") do AgentVera e o navegador do AgentVera são passados com `--mcp-config`. O Amp não tem uma flag de instruções extras, então o campo de papel do agente não é usado; no lugar dele vale o seu `AGENTS.md`.
- **Painéis, worktrees, revisão e fluxos.** Rode o Amp na grade do [workspace](/pt/features/workspace/ "Workspace") ao lado de outros agentes, cada um no seu próprio git worktree para que um não sobrescreva os arquivos do outro. A revisão de código automática confere as mudanças, e nos fluxos (Pro e Team) o Amp pode ser o agente de origem ou de destino.

A grade, os worktrees, a revisão de código e o gerenciador de MCP estão no plano gratuito. Para experimentar, [baixe o AgentVera](/pt/download/ "Baixar o AgentVera").

## Resumindo

Para usar o Amp, instale a CLI, rode `amp login`, escolha um modo com Ctrl+S e descreva a tarefa. Comece a maioria dos threads em `medium`, suba para `high` ou `ultra` nos difíceis e deixe busca e revisão com os subagentes. Coloque as regras do projeto no `AGENTS.md`, as ferramentas em `amp.mcpServers` e use `AMP_API_KEY` com `amp -x` nos scripts. Como o Amp executa ferramentas sem perguntar, mantenha-o numa branch, e você vai tirar o máximo de um agente feito para colocar a mão na massa.

## Perguntas frequentes

**O Amp é gratuito?** Em outubro de 2026, o plano Hobby é gratuito e tem todos os recursos do produto. O uso de modelos é pago por uma assinatura do ChatGPT ou do Claude que você vincula, pelas suas próprias chaves de API ou por créditos do Amp, cobrados de usuários individuais pelo preço de API dos provedores, sem margem. O plano Individual custa 20 dólares por mês e acrescenta 45.000 minutos de orbs nos servidores do Amp.

**Quem desenvolve o Amp hoje?** O Amp nasceu dentro da Sourcegraph. Em dezembro de 2025 virou uma empresa independente, e a CLI, o app web e a documentação agora ficam em ampcode.com.

**Dá para escolher o modelo no Amp?** Não diretamente a cada mensagem. Você escolhe um modo (low, medium, high ou ultra), e o modo define o modelo, o esforço de raciocínio, o prompt e as ferramentas. Em Configurações → Mode Dial → Tune Modes você pode fixar modelos por modo e usar suas próprias chaves de API.

**O Amp lê o CLAUDE.md?** Sim, como alternativa. Em qualquer pasta sem AGENTS.md, o Amp lê AGENT.md ou CLAUDE.md. Ele também carrega skills das pastas do Claude Code, .claude/skills/ e ~/.claude/skills/, a menos que você desative isso.

**O Amp pede permissão antes de rodar comandos?** Não. Por padrão, o Amp não pede aprovação antes de executar ferramentas. Você pode desligar ferramentas nativas com amp.tools.disable, criar regras para ferramentas MCP com amp.mcpPermissions ou escrever um plugin que decide quais chamadas rodam.

---

**Sobre o AgentVera.** AgentVera é um app desktop para macOS, Windows e Linux, desenvolvido pela Solviera Teknoloji. Ele roda 18 agentes de programação com IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) lado a lado, por projeto, em terminais reais com as instalações e logins de CLI do próprio usuário. O plano gratuito tem agentes ilimitados. Baixar: https://agentvera.dev/pt/download/ · Preços: https://agentvera.dev/pt/pricing/