Cursor 3 y Composer 2: tutorial completo para crear agentes autónomos de programación (2026)

Cursor 3 introduce Composer 2, un agente de IA autónomo que ejecuta refactors multi-archivo sin intervención humana, trabaja en background mientras programas y genera commits listos para revisar. Más de 1 millón de personas usan Cursor diariamente en junio de 2026, con más de 50.000 empresas clientes y unos ingresos anualizados que superan los 2.000 millones de dólares. En este tutorial paso a paso aprenderás a instalar Cursor 3, configurar Composer 2, conectar servidores MCP y exprimir los background agents para multiplicar tu productividad como desarrollador.

Qué es Cursor 3 y Composer 2

Cursor 3 es la última versión del IDE de programación basado en IA desarrollado por Anysphere. A diferencia de un asistente de autocompletado clásico, Cursor 3 actúa como un copiloto agéntico: entiende todo el repositorio, modifica varios archivos simultáneamente, ejecuta tests, lanza scripts y deja la rama lista para que apruebes el commit.

El componente estrella de esta versión es Composer 2, un agente autónomo de programación que se integra directamente en el IDE. Composer 2 funciona con Claude Opus 4.8 por defecto y soporta GPT-5.5, Gemini 3.1 Pro y modelos locales vía Ollama. Es capaz de planificar tareas complejas antes de ejecutarlas, lanzar agentes en background mientras tú sigues programando y orquestar herramientas externas a través del protocolo MCP.

Si vienes de la versión anterior, conviene repasar nuestra guía original de Cursor AI y, si quieres entender la filosofía detrás de programar describiendo intenciones, nuestra introducción al vibe coding.

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente preparado:

• Ordenador con macOS 13+, Windows 10/11 o Linux (Ubuntu, Fedora, Arch).
• Procesador moderno con al menos 8 GB de RAM (recomendado 16 GB o más).
• Cuenta gratuita o de pago en cursor.com.
• Conexión estable a internet (los modelos cloud son la opción por defecto).
• Opcional: Ollama instalado si vas a ejecutar modelos locales como Qwen Coder o DeepSeek Coder. Consulta nuestra guía de portátiles para IA local.
• Familiaridad básica con Git y la línea de comandos.

Paso 1: Descargar e instalar Cursor 3

1. Entra en cursor.com y pulsa el botón "Download". La web detecta automáticamente tu sistema operativo.
2. En macOS, abre el archivo .dmg y arrastra el icono de Cursor a la carpeta Aplicaciones. En Windows, ejecuta el instalador .exe y sigue el asistente. En Linux, descarga el .AppImage y dale permisos de ejecución con chmod +x Cursor-3.x.AppImage.
3. Abre Cursor. La primera vez te pedirá importar la configuración de VS Code (atajos, extensiones, tema). Acepta para tener un entorno familiar desde el segundo cero.
4. Inicia sesión con tu cuenta de Cursor (Google, GitHub o email).

Cursor 3 es un fork de VS Code, así que casi todas las extensiones que ya usabas funcionarán igual.

Paso 2: Configurar tu cuenta y elegir modelo

1. Abre el menú Settings → Models (atajo Cmd/Ctrl + ,).
2. Activa los modelos que quieras usar. Por defecto Composer 2 viene con Claude Opus 4.8 (el más potente para refactors complejos). Activa también GPT-5.5 para tareas de explicación y Gemini 3.1 Pro para contextos muy largos.
3. Si quieres usar tus propias claves API, pega tu key de Anthropic, OpenAI o Google en el campo correspondiente. Esto te permite usar tus límites personales en lugar del cupo de Cursor.
4. Para modelos locales, marca "Enable Ollama" e introduce la URL http://localhost:11434. Cursor detectará automáticamente los modelos descargados.
5. En "Privacy Mode" activa el modo privacidad si trabajas con código sensible: ni Cursor ni el proveedor del modelo almacenarán tu código tras la petición.

Paso 3: Tu primer chat con Composer 2 (modo plan)

Composer 2 introduce un "plan mode" que separa el razonamiento de la ejecución. Antes de tocar un solo archivo, el agente te muestra el plan completo para que lo apruebes.

1. Abre cualquier proyecto en Cursor 3.
2. Pulsa Cmd/Ctrl + I para abrir el panel de Composer 2.
3. En la parte superior verás un desplegable con dos modos: Ask (preguntar) y Agent (ejecutar). Selecciona Agent.
4. Activa el checkbox "Plan first" (en la versión 3.0 está por defecto).
5. Escribe un prompt claro y específico, por ejemplo:

Añade autenticación con JWT al endpoint /api/users de mi aplicación Flask.
Usa la librería flask-jwt-extended, crea un decorador @requires_auth
y añade tests unitarios con pytest en tests/test_auth.py.
Antes de tocar archivos, muéstrame el plan y espera mi confirmación.

6. Composer 2 generará un plan con los archivos que va a crear o modificar, las dependencias que añadirá al requirements.txt y los tests previstos.
7. Revisa el plan, pulsa Approve y el agente ejecutará todos los pasos en orden, mostrando un diff por cada archivo.
8. Acepta cambios uno a uno o pulsa Accept all cuando estés conforme.

Este flujo "plan → aprobación → ejecución" reduce drásticamente los errores típicos de los agentes autónomos. Si quieres profundizar en cómo redactar instrucciones, revisa nuestra guía de prompt engineering.

Paso 4: Refactor multi-archivo autónomo

El caso de uso más espectacular de Composer 2 es el refactor multi-archivo. Composer 2 indexa todo el repositorio y entiende relaciones entre archivos, así que puedes pedirle cambios transversales.

1. Abre el panel de Composer 2 en modo Agent.
2. Asegúrate de que el contexto incluye toda la carpeta del proyecto (icono @Folder).
3. Lanza un prompt como:

   Migra toda la base de código de JavaScript a TypeScript.
   Convierte cada archivo .js en .ts, añade tipados explícitos,
   crea un tsconfig.json sensato y actualiza los imports.
   No rompas los tests existentes y ejecuta npm test al final.

4. Composer 2 generará un plan con cientos de pasos si es necesario y los ejecutará en orden. Verás un widget de progreso con los archivos procesados.
5. Durante la ejecución, el agente lanza el linter y los tests automáticamente. Si un test falla, intenta corregirlo y reintentar (un patrón conocido como self-healing code).
6. Al terminar, revisa el diff acumulado y crea un commit. Composer 2 te propone un mensaje de commit semántico.

Paso 5: Activar background agents

Una de las grandes novedades de Cursor 3 son los background agents: instancias de Composer 2 que trabajan en paralelo mientras tú sigues programando.

1. Abre el panel "Background Agents" desde la barra lateral izquierda (icono de robot).
2. Pulsa New Agent. Te pedirá una tarea y un branch de destino.
3. Define el alcance: por ejemplo "Genera documentación con docstrings para todos los módulos de la carpeta services/".
4. Selecciona si el agente debe abrir una PR automática en GitHub al terminar (requiere conectar tu cuenta).
5. Pulsa Start. El agente se ejecutará en una sandbox aislada con su propia copia del repositorio. Mientras tanto, tú puedes seguir trabajando en local sin interferencias.
6. Cuando termine, recibirás una notificación. Abre la pestaña del agente, revisa el diff y aprueba la PR.

Puedes lanzar varios background agents simultáneos: uno escribiendo tests, otro generando documentación, otro corrigiendo deuda técnica. Es la diferencia entre tener "un copiloto" y tener "un equipo".

Paso 6: Integrar servidores MCP

Composer 2 soporta de forma nativa el Model Context Protocol (MCP), el estándar abierto creado por Anthropic para conectar agentes con herramientas externas. Si quieres entender el protocolo en profundidad, lee nuestra guía completa de MCP.

1. Abre Settings → MCP.
2. Pulsa Add server y elige uno de los servidores oficiales: Filesystem, GitHub, Postgres, Slack, Linear, Notion, Brave Search, etc.
3. Configura las credenciales según el servidor. Para el servidor de GitHub, por ejemplo, necesitas un token personal con permisos repo.
4. Guarda la configuración. Aparecerá en el archivo ~/.cursor/mcp.json.

Ejemplo de configuración MCP para conectar GitHub y Filesystem:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxxxxxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/tuusuario/proyectos"
      ]
    }
  }
}

5. Reinicia Cursor 3. Composer 2 detectará automáticamente las nuevas herramientas y podrá usarlas en cualquier conversación.
6. Prueba con un prompt como "Busca todas las issues abiertas del repo arkaia/web y crea un resumen en formato Markdown". Composer 2 invocará el servidor de GitHub sin que tengas que escribir una sola línea de código.

Comparativa Cursor 3 vs GitHub Copilot vs Windsurf vs Claude Code

Estas son las cuatro herramientas dominantes para programar con agentes de IA en junio de 2026. Cada una tiene su nicho:

Si vienes del ecosistema GitHub puro, revisa también nuestro tutorial de GitHub Copilot Autopilot para comparar con tu propia experiencia.

Buenas prácticas y trucos para Composer 2

• Empieza siempre en "plan mode". Aunque tardes más, evitas refactors masivos no deseados.
• Crea un archivo .cursorrules en la raíz del proyecto con reglas de estilo, convenciones de nombrado y dependencias prohibidas. Composer 2 lo respetará.
• Usa @ para anclar contexto: @File, @Folder, @Docs, @Web, @Git. Cuanto más concreto sea el contexto, mejor el resultado.
• Combina modelos: Claude Opus 4.8 para refactors críticos, Gemini 3.1 Pro para revisiones de contexto largo, GPT-5.5 para explicaciones rápidas. Echa un vistazo a nuestra análisis de Claude Opus y al resumen de frameworks de agentes.
• Lanza background agents por la noche con tareas largas (migraciones, documentación, generación de tests masiva). Por la mañana revisas las PRs.
• Commits pequeños: aprueba commits frecuentes para que el historial Git sea revisable.
• Modo privacidad activado si trabajas con código propietario o cumples GDPR / HIPAA.

Material recomendado para programar con IA

Para sacar el máximo partido a Cursor 3 + Composer 2 conviene tener un hardware decente y un par de libros que aceleren tu curva de aprendizaje. Estas son nuestras recomendaciones con enlaces de afiliado verificados:

• Mac mini M4 16GB / 256GB SSD: sobremesa silencioso y eficiente, perfecto para ejecutar Cursor 3 más Ollama con modelos locales. Ver precio actual en Amazon.
• Mac mini M4 16GB / 512GB SSD: la versión con SSD más amplio si manejas repositorios grandes o varios proyectos en paralelo. Ver precio actual en Amazon.
• BenQ RD280U, monitor 4K para programación: panel diseñado específicamente para código (modo Coding, proporción 3:2, anti-reflejos). Ver precio actual en Amazon.
• Dell S2725QS, monitor 27" 4K 120Hz: equilibrio entre productividad y gaming si compartes equipo. Ver precio actual en Amazon.
• Libro "ChatGPT para Hackers y Programadores" (Miguel Segovia): casos prácticos de prompting orientado a desarrolladores. Ver precio actual en Amazon.
• Libro "El arte de la Ingeniería de Prompts con ChatGPT": ideal para mejorar la calidad de tus prompts a Composer 2. Ver precio actual en Amazon.
• Wacom Intuos Pro M, tableta gráfica: útil si combinas diseño UI y desarrollo. Ver precio actual en Amazon.

Conclusión

Cursor 3 con Composer 2 marca un antes y un después en cómo programamos en 2026. Ya no se trata de "un autocompletado más listo", sino de delegar tareas completas a agentes autónomos que planifican, ejecutan, prueban y proponen commits. La combinación de plan mode, background agents y soporte nativo de MCP convierte a Cursor 3 en la opción más completa para equipos de desarrollo.

El consejo final: empieza con tareas pequeñas (un test, un refactor de una función), gana confianza en el flujo y luego escala a refactors masivos y migraciones completas. La curva de aprendizaje es corta y la productividad que ganas es enorme.

Preguntas frecuentes (FAQ)