# Cómo usar Amp: guía paso a paso de la CLI de Amp

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

Cómo usar Amp, el agente de programación: instala la CLI, inicia sesión, elige un modo en el Dial y configura AGENTS.md, servidores MCP, subagentes y créditos.

**En resumen:**

- Instala la CLI de Amp con un solo comando curl (macOS, Linux, Windows mediante WSL), ejecuta amp login y luego amp dentro de un proyecto. Cada conversación es un thread guardado en ampcode.com.
- En lugar de un modelo eliges un modo en el Dial: low, medium, high o ultra. Elígelo con Ctrl+S antes del primer mensaje, porque un thread conserva su modo.
- Las reglas del proyecto van en AGENTS.md; los ajustes y servidores MCP, en ~/.config/amp/settings.json o .amp/settings.json. Hobby es gratis; el uso de modelos sale de tus suscripciones, claves o créditos.

Para usar Amp, instalas la CLI con `curl -fsSL https://ampcode.com/install.sh | bash`, inicias sesión con `amp login`, ejecutas `amp` dentro de un proyecto y describes lo que quieres. Antes del primer mensaje eliges un modo en el Dial con Ctrl+S: `low`, `medium`, `high` o `ultra`. A partir de ahí Amp lee tu código, edita archivos y ejecuta comandos, y toda la conversación queda guardada como un thread que puedes reabrir o compartir.

Ese es el ciclo básico. Esta guía cubre el resto: el inicio de sesión para scripts y CI, los atajos que usarás a diario, los modos, subagentes como el oracle, `settings.json`, `AGENTS.md`, los servidores MCP, el modo execute, lo que cuesta Amp y cómo usarlo junto a otros agentes de CLI. Todo se basa en la documentación oficial de Amp a octubre de 2026.

## Qué es Amp

Amp es un [agente de programación](/es/glossary/coding-agent/ "Qué es un agente de programación") y un entorno de desarrollo. Nació dentro de Sourcegraph y desde su separación en diciembre de 2025 lo desarrolla una empresa independiente. No está atado a un solo proveedor de modelos: Amp elige el modelo según el modo que selecciones, y puede usar tu suscripción de ChatGPT, tu suscripción de Claude (en su modo Claude Code) o tus propias claves de API.

Puedes usarlo en tres sitios: la app web en ampcode.com (sin instalar nada), las apps para macOS, iPhone, iPad y Android, y la CLI de terminal, que es el tema de esta guía. Cada conversación es un **thread** con su propia URL. Amp también puede ejecutar un thread en un **orb**, una máquina que Amp crea para ese thread en sus servidores, o en un runner que alojes tú.

## Paso 1: instala la CLI

| Plataforma | Comando |
| --- | --- |
| macOS, Linux | `curl -fsSL https://ampcode.com/install.sh \| bash` |
| Windows | Ejecuta el mismo comando dentro de WSL |

La CLI funciona en macOS, Linux y Windows mediante WSL. En Windows, la documentación recomienda WezTerm o Alacritty en lugar de Windows Terminal, porque el portapapeles funciona mejor. La página de instalación también tiene pestañas para Windows y Homebrew.

Amp se actualiza solo en segundo plano. `amp update` actualiza a mano, `amp version` muestra la versión instalada y `amp --help` lista todos los comandos. El autocompletado de la shell es una línea, por ejemplo `source <(amp completions zsh)` (bash y pwsh también funcionan; fish usa `amp completions fish | source`).

## Paso 2: inicia sesión

```bash
amp login
```

`amp login` abre el navegador y añade una cuenta. La CLI puede guardar varias: `amp account list` las muestra, `amp account switch <email-or-user-id>` elige la que usarán los siguientes comandos y `amp logout` elimina la activa (`--all` las elimina todas).

Para scripts, CI y máquinas sin navegador, usa un token de acceso:

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

El token se crea en los ajustes de ampcode.com y empieza por `sgamp_`. El token de sesión que guarda `amp login` caduca en menos de una hora y no se puede renovar, así que la CLI no lo acepta ahí.

Dos vinculaciones opcionales cambian quién paga el uso de modelos:

- **Suscripción de ChatGPT:** `amp config model-providers add-chatgpt-subscription` (o el atajo `amp add-chatgpt-sub`) vincula un plan de ChatGPT, de modo que el uso de modelos de OpenAI se descuenta de él.
- **Suscripción de Claude:** solo funciona en el modo **Claude Code** de Amp, que se elige en el Dial. Los modos propios de Amp nunca tiran de tu plan de Claude.

## Paso 3: lo básico de la CLI

Ejecuta `amp` en un proyecto y escribe. La entrada por pipe se convierte en el primer mensaje, así que `echo "commit all my changes" | amp` también funciona. El atajo que más usarás es **Ctrl+O**, que abre la paleta de comandos.

| Atajo | Qué hace |
| --- | --- |
| `Ctrl+O` | Abre la paleta de comandos |
| `Ctrl+S` | Gira el Dial (antes del primer mensaje) |
| `@` | Menciona un archivo |
| `Ctrl+V` | Pega una imagen, también en macOS |
| `Ctrl+G` | Escribe el prompt en `$EDITOR` |
| `Ctrl+R` | Abre el historial de prompts |
| `Esc Esc` | Interrumpe al agente |
| `Ctrl+C Ctrl+N` | Archiva el thread y empieza uno nuevo |
| `Ctrl+C Ctrl+C` | Sale |

Si escribes mientras Amp trabaja, Enter lo **reorienta**: tu mensaje llega después del paso actual, sin esperar a que termine todo el turno. Para dejar un mensaje en cola hasta que el agente acabe, ejecuta `prompt: queue message` desde la paleta. Shift+Enter añade un salto de línea en los terminales que lo admiten; Ctrl+J funciona en todos. Dentro de tmux, ejecuta `tmux set -s extended-keys on` para que Shift+Enter funcione.

Desde la paleta, `ide connect` conecta Amp con VS Code, Cursor, Windsurf, Zed o Neovim (Neovim necesita un plugin). `amp config keymap` muestra todos los atajos.

## Paso 4: elige un modo en el Dial

Amp no te pide un modelo, te pide un modo. Cada modo combina modelo, esfuerzo de razonamiento, prompt de sistema y herramientas, ajustados a un nivel de dificultad:

| Modo | Para qué |
| --- | --- |
| `low` | Cambios pequeños y bien definidos |
| `medium` | La mayoría del trabajo; la recomendación por defecto de la documentación |
| `high` | Problemas difíciles o sutiles |
| `ultra` | Trabajo abierto, como migraciones y arquitectura |

Pulsa **Ctrl+S antes del primer mensaje** para girar el Dial, o abre la paleta y escribe `mode`. Un thread conserva el modo con el que empezó; si elegiste mal, abre un thread nuevo en lugar de pelearte con él. Empezar demasiado alto malgasta tiempo y créditos en un cambio sencillo; empezar demasiado bajo puede salir más caro si necesitas varios intentos.

Si quieres controlar los modelos, en Ajustes → Mode Dial → Tune Modes puedes fijar modelos por modo y usar tus propias claves de API. Si prefieres elegir un modelo concreto en cada sesión, un agente multiproveedor como opencode encaja mejor con esa costumbre.

## Paso 5: subagentes, el oracle y el librarian

Amp puede delegar trabajo acotado en [subagentes](/es/glossary/subagent/ "Qué es un subagente"), cada uno con su propia ventana de contexto:

- **Task** hace el trabajo delegado de principio a fin e informa del resultado. Puede editar archivos y ejecutar comandos, y tiene skills de solo lectura para buscar en tu código, investigar otro repositorio, revisar un cambio y planificar.
- **Read Thread** lee y resume otros threads de Amp.

Los dos usan el mismo modelo que el thread que los lanzó. Amp los elige por su cuenta cuando el trabajo lo pide, sobre todo en modo `medium`, y también puedes pedírselos directamente: “reparte esto entre subagentes”.

El oracle (un revisor que nunca edita archivos), el librarian (clona otros repositorios en `/tmp` y los explica) y el finder (búsqueda rápida de código) forman ahora parte de Task. Para usarlos como herramientas separadas con el modelo que elijas, instálalos como plugins:

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

## Paso 6: ajustes

Amp lee dos archivos de ajustes, y los valores del workspace mandan:

- **Usuario:** `~/.config/amp/settings.json` (o `.jsonc`).
- **Workspace:** `.amp/settings.json` en el proyecto.

`amp config edit` abre el archivo de usuario y `amp config edit --workspace` el del proyecto. Todas las claves empiezan por `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` muestra lo que cuesta cada thread.
- `amp.tools.disable` desactiva herramientas por nombre, con comodines `*`; `amp tools list` lista las integradas.
- `amp.git.commit.ampThread.enabled` y `amp.git.commit.coauthor.enabled` controlan lo que Amp añade a sus mensajes de commit, como el trailer `Amp-Thread-ID` que enlaza un commit con su thread.

Algo que conviene saber antes de empezar: por defecto **Amp no pide aprobación antes de ejecutar herramientas**. Trabaja en una rama, haz commits a menudo y usa `amp.tools.disable` o un plugin si quieres poner límites. Si quieres un agente que pregunte primero por defecto, Claude Code y Codex CLI están pensados en torno a las solicitudes de aprobación.

Las skills funcionan como en otros agentes: una carpeta con un `SKILL.md`. Amp carga las skills del proyecto desde `.agents/skills/`, las personales desde `~/.config/amp/skills/` y `~/.config/agents/skills/`, y también las carpetas de Claude Code `.claude/skills/` y `~/.claude/skills/`.

## Paso 7: AGENTS.md

`AGENTS.md` guarda las reglas de un proyecto: cómo compilar, probar y pasar el linter, qué convenciones seguir, qué carpetas no tocar. Amp lee el de la carpeta actual y el de cada carpeta superior hasta tu carpeta personal, y siempre los incluye. Un `AGENTS.md` en una subcarpeta se añade cuando Amp lee un archivo de esa carpeta. Si el proyecto no tiene ninguno, Amp se ofrece a escribirlo.

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

Algunos detalles útiles:

- **Las menciones con @** incorporan otros archivos: rutas relativas, rutas `@~/` y patrones como `@docs/*.md`.
- **Las reglas personales** van en `~/.config/amp/AGENTS.md` (o `~/.config/AGENTS.md`).
- **Alternativa:** en una carpeta sin `AGENTS.md`, Amp lee `AGENT.md` o `CLAUDE.md`, así que un proyecto de Claude Code funciona desde el primer día.
- **Reglas acotadas:** un archivo mencionado puede llevar `globs:` en el front matter, para que sus indicaciones solo se apliquen cuando Amp trabaja en archivos que coinciden.

Qué poner en el archivo lo explicamos en [cómo escribir CLAUDE.md y AGENTS.md](/es/blog/claude-md-agents-md/ "Cómo escribir CLAUDE.md y AGENTS.md").

## Paso 8: servidores MCP

Los [servidores MCP](/es/blog/what-is-mcp-server/ "Qué es un servidor MCP") dan a Amp herramientas nuevas: un navegador, un gestor de incidencias, búsqueda en documentación. La forma más rápida de añadir uno es la CLI:

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

Los dos acaban en tus ajustes bajo `amp.mcpServers`. Un servidor local es un comando, uno remoto es una URL, y `${VAR}` toma valores del entorno:

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

Los servidores definidos en el `.amp/settings.json` de un workspace no se ejecutan hasta que los apruebas con `amp mcp approve <name>`; `amp mcp doctor` muestra el estado de cada uno. Si el mismo servidor está definido en varios sitios, `--mcp-config` gana al archivo del workspace, que a su vez gana a tus ajustes de usuario. Como cada servidor añade sus herramientas al contexto, la documentación sugiere meter los servidores que se usan poco dentro de una skill (con un `mcp.json`), para que sus herramientas solo se carguen cuando se carga la skill.

## Paso 9: threads y modo execute

Cada thread tiene una URL como `https://ampcode.com/threads/T-…`. `amp threads continue T-…` lo retoma en el terminal, `amp threads share T-… --visibility unlisted` lo hace compartible y escribir `@T-…` en un prompt añade otro thread como contexto. Los threads que empiezas fuera de un workspace son privados.

Para scripts y CI, el **modo execute** ejecuta un prompt y termina:

```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` se ejecuta en tu máquina y se activa solo cuando la salida está redirigida. `-ox` ejecuta el prompt en un orb. `--stream-json` da una salida legible por máquinas y `--mcp-config` añade servidores MCP solo para esa ejecución.

## Cuánto cuesta Amp (a octubre de 2026)

| Plan | Precio | Qué incluye |
| --- | --- | --- |
| Hobby | Gratis | Todas las funciones del producto; orbs de pago por uso; tus suscripciones o claves |
| Individual (Megawatt) | 20 dólares al mes | Uso incluido más 45.000 minutos de orbs en los servidores de Amp |
| Teams | Sin coste adicional | Threads, skills y facturación compartidos, créditos comunes, SSO |
| Enterprise | A medida | Controles de administración, registros de auditoría, opciones de retención de datos |

El uso de modelos sale de uno de tres sitios: una suscripción de ChatGPT o Claude vinculada, tus propias claves de API o créditos de Amp. Cuando se acaba el uso incluido añades créditos, y Amp los cobra según el coste real de modelos y herramientas de cada thread, sin margen sobre los precios de API de los proveedores para particulares y workspaces que no son enterprise. No hace falta un plan de pago para comprar créditos. La búsqueda web también consume créditos. Los créditos caducan doce meses después de la compra, y `amp usage` muestra tu saldo. Los orbs se facturan por minuto y se pausan cuando están inactivos; los runners en tu propia máquina son gratis.

## Errores frecuentes

- **Modo equivocado, y Ctrl+S no lo cambia.** El thread ya tiene un primer mensaje. Empieza uno nuevo con Ctrl+C Ctrl+N.
- **La CI dice que tu sesión no es válida.** El token de sesión de `amp login` dura poco. Pon en `AMP_API_KEY` un token de acceso `sgamp_`.
- **Un servidor MCP del workspace nunca aparece.** Necesita aprobación: `amp mcp approve <name>` y luego comprueba con `amp mcp doctor`.
- **No se usa tu plan de Claude.** Solo el modo Claude Code tira de él; de `low` a `ultra` usan el enrutado propio de Amp.
- **Amp ejecutó un comando que no esperabas.** Por defecto no pregunta. Desactiva la herramienta o trabaja en una rama desechable.
- **En tmux, Shift+Enter envía el prompt.** Activa `extended-keys` o usa Ctrl+J.

## Amp junto a otras CLI en AgentVera

Amp tiene su propia app web, app de escritorio y orbs, y si Amp es el único agente que usas, puede que no necesites más. La cosa se complica cuando Amp trabaja junto a Claude Code, Codex o Gemini CLI en el mismo proyecto. AgentVera es una app de escritorio que ejecuta estas CLI lado a lado en terminales reales, con tus propias instalaciones e inicios de sesión. El [soporte de Amp](/es/agents/amp/ "Amp en AgentVera") funciona así:

- **Tu sesión de Amp.** Amp usa su propio inicio de sesión de ampcode.com; si no has iniciado sesión, el terminal del agente te lo pide en el primer arranque. En Ajustes → Cuentas → Cuentas de otros agentes puedes añadir más cuentas de Amp, que funcionan con claves de API, y dar a cada agente una lista ordenada de cuentas de respaldo.
- **Un thread por agente.** Para cada agente se crea de antemano un thread nuevo con `amp threads new`, y el agente vuelve a él con `threads continue` en los siguientes arranques.
- **Modos, no modelos.** Eliges low, medium, high o ultra para cada agente, y se pasa con `--mode`.
- **MCP y el navegador.** Los servidores que añades en el [gestor de MCP](/es/features/mcp-manager/ "Gestor de MCP") de AgentVera y el navegador de AgentVera se pasan con `--mcp-config`. Amp no tiene un flag de instrucciones adicionales, así que el campo de rol del agente no se usa; en su lugar se aplica tu `AGENTS.md`.
- **Paneles, worktrees, revisión y flujos.** Ejecuta Amp en la cuadrícula del [workspace](/es/features/workspace/ "Workspace") junto a otros agentes, cada uno en su propio git worktree para que no se pisen los archivos. La revisión de código automática comprueba sus cambios, y en los flujos (Pro y Team) Amp puede ser el agente de origen o de destino.

La cuadrícula, los worktrees, la revisión de código y el gestor de MCP están en el plan gratuito. Para probarlo, [descarga AgentVera](/es/download/ "Descargar AgentVera").

## En resumen

Para usar Amp, instala la CLI, ejecuta `amp login`, elige un modo con Ctrl+S y describe la tarea. Empieza la mayoría de los threads en `medium`, sube a `high` o `ultra` para los difíciles y deja la búsqueda y la revisión a los subagentes. Pon las reglas del proyecto en `AGENTS.md`, las herramientas en `amp.mcpServers` y usa `AMP_API_KEY` con `amp -x` en los scripts. Como Amp ejecuta herramientas sin preguntar, mantenlo en una rama y sacarás el máximo partido a un agente pensado para ponerse manos a la obra.

## Preguntas frecuentes

**¿Amp es gratis?** A octubre de 2026, el plan Hobby es gratuito e incluye todas las funciones del producto. El uso de modelos lo pagas con una suscripción de ChatGPT o Claude que vincules, con tus propias claves de API o con créditos de Amp, que Amp cobra a precio de API del proveedor sin margen para usuarios individuales. El plan Individual cuesta 20 dólares al mes y añade 45.000 minutos de orbs en los servidores de Amp.

**¿Quién desarrolla Amp ahora?** Amp nació dentro de Sourcegraph. En diciembre de 2025 se separó como empresa independiente, y la CLI, la app web y la documentación están ahora en ampcode.com.

**¿Puedo elegir el modelo en Amp?** No directamente en cada mensaje. Eliges un modo (low, medium, high o ultra) y el modo decide el modelo, el esfuerzo de razonamiento, el prompt y las herramientas. En Ajustes → Mode Dial → Tune Modes puedes fijar modelos por modo y usar tus propias claves de API.

**¿Amp lee CLAUDE.md?** Sí, como alternativa. En cualquier carpeta sin AGENTS.md, Amp lee AGENT.md o CLAUDE.md. También carga skills de las carpetas de Claude Code, .claude/skills/ y ~/.claude/skills/, salvo que lo desactives.

**¿Amp pide permiso antes de ejecutar comandos?** No. Por defecto Amp no pide aprobación antes de ejecutar herramientas. Puedes desactivar herramientas integradas con amp.tools.disable, poner reglas a las herramientas MCP con amp.mcpPermissions o escribir un plugin que decida qué llamadas se ejecutan.

---

**Sobre AgentVera.** AgentVera es una app de escritorio para macOS, Windows y Linux, desarrollada por Solviera Teknoloji. Ejecuta 18 agentes de programación con IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) en paralelo, por proyecto, en terminales reales con las instalaciones y sesiones de CLI del propio usuario. El plan gratuito tiene agentes ilimitados. Descargar: https://agentvera.dev/es/download/ · Precios: https://agentvera.dev/es/pricing/