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

URL: https://agentvera.dev/es/blog/how-to-use-droid/ · Publicado: 2026-11-14

Cómo usar Factory Droid en la terminal: instalar, iniciar sesión, elegir modelo, usar droid exec con niveles de autonomía y configurar AGENTS.md, MCP y droids propios.

**En resumen:**

- Instala con curl -fsSL https://app.factory.ai/cli | sh (o brew install --cask droid), ejecuta droid en un proyecto, entra desde el navegador y describe la tarea. Droid pregunta antes de editar archivos o lanzar comandos.
- Para scripts y CI, droid exec es de solo lectura por defecto; --auto low permite ediciones, medium añade instalaciones, builds, tests y commits, y high añade pushes y deploys. Usa FACTORY_API_KEY sin navegador.
- El plan Free funciona con tu propia inferencia (ChatGPT, Copilot, OpenRouter o claves de API); Pro cuesta 20 $ al mes a noviembre de 2026. Las reglas van en AGENTS.md; los ajustes y servidores MCP, en ~/.factory/.

Para usar Droid, el agente de código de Factory, instalas la CLI con `curl -fsSL https://app.factory.ai/cli | sh`, ejecutas `droid` dentro de un proyecto, inicias sesión en el navegador y describes la tarea. **Droid pregunta antes de editar un archivo o ejecutar un comando; para scripts y CI existe `droid exec`, que es de solo lectura hasta que subes su autonomía.**

Esta guía cubre la CLI de Droid a noviembre de 2026 (versión 1.12): instalación, inicio de sesión, modelos, la sesión interactiva, `droid exec` y sus niveles de autonomía, AGENTS.md, servidores MCP, droids propios y cuánto cuesta.

## Qué es Droid

Droid es el agente de código para terminal de [Factory](https://factory.com "Factory"). Lee tu código, propone cambios y los aplica cuando los apruebas. El mismo agente funciona también en las apps de escritorio y web de Factory, en integraciones con IDE y a través de un SDK. La versión 1.0 salió el 29 de octubre de 2026, y aparecen versiones nuevas varias veces por semana.

Droid no está atado a un solo proveedor de modelos. Ofrece modelos de Anthropic, OpenAI, Google y xAI, además de modelos open-weight que Factory agrupa como “Droid Core”, y puedes añadir tus propios endpoints.

## Paso 1: instala la CLI

En macOS o Linux:

```bash
curl -fsSL https://app.factory.ai/cli | sh
```

Otras opciones:

```bash
brew install --cask droid      # Homebrew
npm install -g droid           # npm
```

En Windows PowerShell:

```powershell
irm https://app.factory.ai/cli/windows | iex
```

En Linux, el inicio de sesión también necesita `xdg-utils` (`sudo apt-get install xdg-utils`). Más adelante, actualiza con `droid update`.

## Paso 2: inicia sesión

```bash
cd my-project
droid
```

La primera ejecución abre el navegador para iniciar sesión con una cuenta de Factory. Para CI y otras máquinas sin navegador, crea una clave de API en los ajustes de Factory y expórtala:

```bash
export FACTORY_API_KEY=fk-...
```

## Paso 3: trabaja en una sesión

Describe la tarea con palabras sencillas. Droid explica lo que piensa hacer y luego pregunta antes de cada edición o comando. Teclas y comandos útiles:

- `Shift+Tab` alterna entre el modo normal y el modo spec, en el que Droid escribe un plan antes de cambiar código.
- `!` ejecuta tú mismo un comando de shell; `?` muestra los atajos.
- `/model` cambia el modelo, `/settings` abre los ajustes y `/review` pide una revisión de los cambios.
- `/compress` acorta una conversación larga; `/sessions` lista las anteriores.

Para volver más tarde, ejecuta `droid --resume` (o `droid --resume <id>`). `droid search "checkout bug"` encuentra una sesión antigua por su texto, y `--fork <id>` copia una.

## Paso 4: elige un modelo

Cambia de modelo con `/model` en una sesión, con `-m` en la línea de comandos o con una clave `model` en los ajustes. En los planes de pago, cada modelo cuenta contra tu uso con un multiplicador: a noviembre de 2026, Claude Opus 5.5 cuenta 1,6x, Claude Sonnet 5.5 0,8x y Claude Haiku 5.5 0,04x. Usa un modelo pequeño para ediciones rutinarias y uno grande para diseño y depuración.

Para usar tu propia clave, añade un modelo propio a `~/.factory/settings.json`:

```json
{
  "customModels": [
    {
      "model": "claude-sonnet-5-5",
      "displayName": "Sonnet (my key)",
      "baseUrl": "https://api.anthropic.com",
      "apiKey": "${ANTHROPIC_API_KEY}",
      "provider": "anthropic"
    }
  ]
}
```

`provider` es `anthropic`, `openai`, `generic-chat-completion-api` o `bedrock-converse`. Las claves se quedan en tu equipo.

## Paso 5: droid exec y niveles de autonomía

`droid exec` ejecuta una sola tarea sin chat, que es lo que quieres en scripts y CI:

```bash
droid exec "summarize the changes on this branch"
droid exec --auto low "fix the failing unit test in price.test.ts"
droid exec -f task.md -o json --auto medium
```

Por defecto es de solo lectura. Tú amplías lo que puede hacer:

| Nivel | Qué permite |
|---|---|
| (por defecto) | Solo lectura |
| `--auto low` | Edición de archivos |
| `--auto medium` | Además instalaciones, builds, tests, commit, checkout y pull |
| `--auto high` | Además pushes y deploys |

`--skip-permissions-unsafe` desactiva todas las confirmaciones; resérvalo para contenedores desechables. Ten en cuenta que el código de salida 0 significa que Droid terminó, no que la tarea saliera bien, así que comprueba el resultado en CI. Para las sesiones interactivas puedes fijar un nivel por defecto con `sessionDefaultSettings.autonomyLevel` y reglas más finas con `permissionRules` (allow, ask, block) en los ajustes.

## Paso 6: AGENTS.md y ajustes

Droid lee `AGENTS.md` como las instrucciones del repositorio. Mantenlo corto: el stack, cómo ejecutar los tests, qué no tocar y qué significa “terminado”. Nuestra guía sobre [CLAUDE.md y AGENTS.md](/es/blog/claude-md-agents-md/ "CLAUDE.md y AGENTS.md") explica qué poner en él.

Los ajustes están en `~/.factory/settings.json` para ti y en `.factory/settings.json` para el proyecto, cada uno con un `settings.local.json` para cambios locales que no subes al repositorio.

## Paso 7: servidores MCP y droids propios

Añade servidores MCP desde la línea de comandos:

```bash
droid mcp add docs https://example.com/mcp --type http
droid mcp add memory "npx -y @modelcontextprotocol/server-memory"
```

Se guardan en `~/.factory/mcp.json` (o en `.factory/mcp.json` para el proyecto) bajo `mcpServers`. En una sesión, `/mcp` los gestiona, incluidos los inicios de sesión OAuth.

Los droids propios son subagentes: un archivo Markdown con una cabecera YAML (`name`, `description`, `model`, `tools` y más) en `.factory/droids/` o `~/.factory/droids/`. Droid les pasa trabajo con su herramienta Task, y `/droids` los gestiona. Un pequeño droid “escritor de tests” o “revisor” con un modelo barato es un buen primer droid.

## Cuánto cuesta Droid (a noviembre de 2026)

| Plan | Precio | Notas |
|---|---|---|
| Free | 0 $ | Tú pones la inferencia: ChatGPT, Copilot, OpenRouter o tus propias claves |
| Pro | 20 $/mes | Todos los modelos, app de escritorio, CLI y SDK |
| Plus | 100 $/mes | Unas 5 veces el uso de Pro |
| Max | 200 $/mes | Unas 10 veces el uso de Pro |
| Teams | 60 $/mes + 40 $/puesto | Hasta 10 puestos |

Consulta la [página de precios de Factory](https://factory.com/pricing "Precios de Factory") antes de decidir; los planes cambian a menudo.

## Errores habituales

- **Enlaces antiguos a la documentación.** La documentación pasó de docs.factory.ai a [docs.factory.com](https://docs.factory.com "Documentación de Factory"); las URL de instalación siguen usando app.factory.ai.
- **Usar exec con autonomía alta demasiado pronto.** Empieza los jobs de CI con `--auto low` y sube el nivel solo en los pasos que lo necesiten.
- **Fiarse del código de salida 0.** Solo significa que la ejecución terminó. Revisa los tests o el diff después.
- **`-r` significa dos cosas.** En `droid`, `-r` retoma una sesión; en `droid exec`, fija el esfuerzo de razonamiento. Escribe `--resume` completo para evitar sorpresas.

## Droid junto a otras CLI en AgentVera

Si Droid es tu único agente, puede que las apps de Factory te basten. La cosa se complica cuando Droid trabaja junto a Claude Code, Codex o Gemini CLI en el mismo proyecto. [AgentVera](/es/ "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 Droid](/es/agents/factory-droid/ "Factory Droid en AgentVera") funciona así:

- **Una sesión por agente.** AgentVera encuentra la sesión que crea Droid y la reabre con `droid --resume <id>` en los siguientes arranques, así que la conversación sobrevive a un reinicio de la app.
- **Modelo, esfuerzo y rol.** El modelo y el esfuerzo que eliges para el agente se pasan mediante un archivo de ajustes, y el rol del agente con `--append-system-prompt`.
- **Tu inicio de sesión o tus claves de API.** Droid conserva tu inicio de sesión de Factory. En Ajustes → Cuentas puedes añadir cuentas con `FACTORY_API_KEY` y dar a cada agente la suya.
- **Paneles, worktrees y revisión.** Ejecuta Droid en la cuadrícula del [workspace](/es/features/workspace/ "Workspace") junto a otros agentes, cada uno en su propio git worktree, y comprueba sus cambios con la [revisión de código](/es/features/code-review/ "Revisión de código").

El plan gratuito incluye hasta 18 agentes, MCP, Git, Docker, SSH, revisión de código y ahorro de tokens. Pro cuesta 9,99 $ al mes; si nunca has tenido una prueba, tu primer inicio de sesión en la app activa Pro durante 7 días sin tarjeta. Para probarlo, [descarga AgentVera](/es/download/ "Descargar AgentVera").

## Conclusión

Para empezar con Droid bastan dos comandos: el script de instalación y `droid`. Lo que importa después es el control: mantén las sesiones interactivas con aprobación, empieza `droid exec` con `--auto low`, pon las reglas del proyecto en `AGENTS.md` y elige un modelo para cada tarea teniendo en cuenta el multiplicador de uso.

Fuentes: [inicio rápido de Droid](https://docs.factory.com/cli/getting-started/quickstart "Inicio rápido de Droid"), [referencia de la CLI](https://docs.factory.com/docs/droid-cli/cli-reference "Referencia de la CLI de Droid"), [droid exec](https://docs.factory.com/docs/droid-exec/overview "droid exec"), [modelos](https://docs.factory.com/docs/models "Modelos de Droid"), [MCP](https://docs.factory.com/docs/harness/mcp "MCP en Droid"), [changelog](https://docs.factory.com/changelog/cli-updates "Changelog de la CLI de Droid").

## Preguntas frecuentes

**¿Factory Droid es gratis?** Hay un plan Free de 0 $ en el que tú pones la inferencia: inicia sesión con ChatGPT, GitHub Copilot u OpenRouter, o añade tus propias claves de API. Los planes de pago, a noviembre de 2026, son Pro por 20 $, Plus por 100 $ y Max por 200 $ al mes, con más uso en cada escalón.

**¿Puedo usar mi propia clave de API con Droid?** Sí. Añade una entrada customModels a ~/.factory/settings.json con el nombre del modelo, la URL base, el proveedor y la clave (puede leer la clave de una variable de entorno). Las claves se quedan en tu equipo, y los modelos propios funcionan en la CLI y en la app de escritorio.

**¿Qué diferencia hay entre droid y droid exec?** droid abre una sesión interactiva que pregunta antes de cada edición o comando. droid exec ejecuta una sola tarea sin chat, para scripts y CI. Es de solo lectura salvo que subas la autonomía con --auto low, medium o high.

**¿Droid lee AGENTS.md?** Sí. AGENTS.md es el archivo de instrucciones que Droid lee en un repositorio: pon ahí el stack, el comando de tests, las reglas y lo que no se debe tocar.

**¿Cómo retomo una sesión de Droid?** Ejecuta droid --resume para elegir una sesión reciente, o droid --resume <id> para una concreta. droid search "texto" encuentra sesiones antiguas, y --fork <id> copia una para que pruebes otra dirección.

---

**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/