Cursor se integró oficialmente con los IDEs de JetBrains — IntelliJ IDEA, PyCharm y WebStorm — mediante el Agent Client Protocol (ACP), un estándar abierto co-desarrollado por JetBrains y Zed Industries. Los usuarios de JetBrains ahora pueden acceder a los modelos de OpenAI, Anthropic y Google directamente desde su IDE habitual, sin migrar a VS Code. Además, Cursor lanzó MCP Apps (versión 2.6), que permiten renderizar interfaces interactivas como charts de Amplitude, diagramas de Figma y whiteboards de tldraw dentro del editor.
En 30 segundos
- Cursor funciona dentro de IntelliJ, PyCharm y WebStorm gracias al Agent Client Protocol (ACP), sin necesidad de abandonar JetBrains.
- El acceso incluye modelos frontier de OpenAI, Anthropic, Google y los propios de Cursor, con indexación semántica del codebase completo.
- Las nuevas MCP Apps (Cursor 2.6) traen interfaces interactivas al chat del agente: gráficos de analytics, diagramas de diseño y pizarras colaborativas.
- Los planes Teams y Enterprise suman Team Marketplaces para distribuir plugins internos con gobernanza centralizada.
Cursor es un editor de código con IA integrada, originalmente basado en un fork de VS Code, que ofrece autocompletado inteligente, chat contextual y capacidades agénticas para desarrollo de software. ACP (Agent Client Protocol) es un protocolo abierto que estandariza la comunicación entre agentes de IA y editores de código, permitiendo que cualquier agente compatible funcione en cualquier IDE que implemente el protocolo.
Qué es Cursor ACP y por qué importa para los usuarios de JetBrains
El Agent Client Protocol nació como un estándar abierto co-desarrollado por JetBrains y Zed Industries. La idea central: definir una interfaz común para que agentes de IA se conecten a cualquier IDE sin necesidad de integraciones custom por cada editor. Antes de ACP, si querías usar Cursor, tu única opción era su app standalone (el fork de VS Code). Si tu stack giraba alrededor de IntelliJ o PyCharm, mala suerte.
Eso cambió. Con ACP, Cursor funciona como un agente que se conecta al IDE de JetBrains a través de un protocolo estandarizado. No es un plugin tradicional que necesite adaptarse a cada versión del IDE. Es una capa de comunicación que permite al agente leer tu código, proponer cambios, ejecutar comandos y trabajar con el contexto completo del proyecto.
Para los equipos que llevan años usando JetBrains y no querían migrar a VS Code solo por las capacidades de IA de Cursor, esto resuelve un problema concreto. Mantenés las refactorizaciones, el debugger, el soporte de frameworks y la deep code intelligence de JetBrains. Y le sumás las capacidades agénticas de Cursor encima. Si te interesa, podes leer mas sobre la guerra de precios con Devin.
IDEs compatibles y cómo instalar Cursor en JetBrains IDE
La integración funciona en los IDEs principales de JetBrains:
- IntelliJ IDEA (Community y Ultimate)
- PyCharm (Community y Professional)
- WebStorm
- Otros IDEs de JetBrains que soporten ACP
El proceso de instalación es más directo de lo que esperarías:
- Paso 1: Abrí tu IDE de JetBrains y buscá el selector de agentes en la barra de herramientas.
- Paso 2: Hacé clic en “ACP Registry” para abrir el registro de agentes disponibles.
- Paso 3: Buscá “Cursor” en el listado de agentes verificados e instalalo.
- Paso 4: Autenticate con tu cuenta de Cursor existente.
- Paso 5: Listo. El agente ya tiene acceso al contexto de tu proyecto.
Un detalle que no es menor: necesitás un plan pago de Cursor. No hay costo adicional por usar la integración con JetBrains — si ya pagás Cursor, el acceso vía ACP está incluido. Pero la versión gratuita de Cursor no alcanza para esta funcionalidad.
Modelos de IA disponibles: OpenAI, Anthropic, Google y Cursor
Una de las ventajas de Cursor sobre herramientas que dependen de un solo proveedor es el acceso multi-modelo. Desde JetBrains, podés usar:
- OpenAI: GPT-4o y modelos de la familia o-series para razonamiento complejo
- Anthropic: Claude Sonnet y Opus para tareas que requieren contexto extenso y análisis detallado
- Google: Gemini para capacidades multimodales
- Cursor: Modelos propios optimizados para completado de código y edición rápida
El harness del agente — es decir, la capa que orquesta cómo el modelo interactúa con tu código — está optimizado para cada proveedor. No es lo mismo pasarle un prompt a GPT-4o que a Claude; Cursor ajusta el formato, el contexto y las instrucciones según el modelo que elijas.
Eso sí, lo que realmente marca la diferencia es la indexación semántica del codebase. Cursor indexa tu proyecto completo y construye un mapa semántico que le permite encontrar funciones, clases y relaciones entre archivos sin que vos tengas que indicarle dónde buscar. En proyectos grandes — pensá en un monorepo con 500 archivos — esto es lo que separa una respuesta útil de una genérica.
Ahora bien, habría que ver cómo se compara la velocidad de indexación en JetBrains versus el cliente standalone de Cursor. JetBrains ya tiene su propio índice interno del proyecto, y no queda del todo claro si Cursor reutiliza esa información o construye uno propio en paralelo. Si te interesa, podes leer mas sobre nuestra guía completa sobre GPT.
MCP Apps: interfaces interactivas dentro del editor
Con la versión 2.6, Cursor introdujo las MCP Apps, y acá es donde la cosa se pone interesante. Hasta ahora, los servidores MCP (Model Context Protocol) devolvían texto: datos, respuestas, fragmentos de código. Las MCP Apps agregan una capa visual: los servidores pueden renderizar interfaces completas dentro del chat del agente.
Tres ejemplos concretos de lo que esto habilita:
Charts de Amplitude
Imaginá que estás trabajando en una feature y querés ver cómo impactó en el engagement de usuarios. En lugar de abrir Amplitude en otra pestaña del navegador, le pedís al agente “mostrá el chart de retención de los últimos 30 días” y el gráfico aparece directamente en el panel del chat. Podés analizar los datos sin salir del editor, y el agente puede interpretar los resultados para sugerir cambios en el código.
Diagramas de Figma
Un diseñador actualiza un componente en Figma. Vos, desde PyCharm, le pedís al agente que traiga el diagrama actualizado del componente. Lo ves inline, comparás contra tu implementación actual y le pedís al agente que ajuste los estilos CSS para que coincidan. Todo sin abrir Figma.
Whiteboards de tldraw
Necesitás diagramar la arquitectura de un servicio antes de implementarlo. Le pedís al agente que abra un whiteboard de tldraw, dibujás el diagrama (o dejás que el agente lo genere basándose en tu descripción) y después usás ese diagrama como contexto para que el agente genere el código base.
El punto clave es que las MCP Apps no son widgets estáticos. Son interfaces interactivas que el agente puede leer, interpretar y usar como contexto para sus respuestas. Es una diferencia significativa respecto a simplemente pegar una imagen en el chat. Si te interesa, podes leer mas sobre todo sobre Gemini y sus capacidades.
Plugins compartidos para equipos: Team Marketplaces
Para equipos que usan Cursor en planes Teams o Enterprise, la nueva funcionalidad de Team Marketplaces permite a los administradores crear repositorios privados de plugins y distribuirlos de forma centralizada.
El flujo es así: un admin entra al Dashboard de Cursor, va a Settings, sección Plugins, e importa plugins desde un repositorio de GitHub. Los miembros del equipo reciben esos plugins automáticamente, sin tener que buscarlos ni instalarlos manualmente.
¿Por qué importa esto? Pensá en un equipo de 30 desarrolladores donde todos necesitan la misma configuración de linting con IA, los mismos servidores MCP para acceder a la documentación interna y las mismas reglas de estilo para generación de código. Sin marketplaces, cada dev tiene que configurar todo a mano. Con marketplaces, el admin lo configura una vez y se distribuye a todos.
El control de acceso permite definir qué plugins son obligatorios y cuáles opcionales. Gobernanza centralizada sin micromanagement.
Cursor standalone vs Cursor en JetBrains: qué cambia
No es lo mismo usar Cursor como app independiente que como agente dentro de JetBrains. Cada opción tiene sus ventajas y limitaciones concretas. Si te interesa, podes leer mas sobre comparativa entre los modelos de Claude.
| Característica | Cursor standalone (VS Code fork) | Cursor en JetBrains (vía ACP) |
|---|---|---|
| Base del editor | Fork de VS Code | IntelliJ / PyCharm / WebStorm |
| Tab completions (Copilot++) | Integrado nativamente | Puede diferir o no estar disponible |
| Chat con agente IA | Completo | Completo vía ACP |
| Modelos disponibles | OpenAI, Anthropic, Google, Cursor | Mismos modelos |
| MCP Apps | Soporte completo | Depende de la implementación ACP |
| Indexación semántica | Nativa de Cursor | Nativa de Cursor + índice de JetBrains |
| Refactoring avanzado | Capacidades de VS Code | Deep code intelligence de JetBrains |
| Debugger | Debugger de VS Code | Debugger avanzado de JetBrains |
| Soporte de frameworks | Vía extensiones | Nativo (Spring, Django, React, etc.) |
| Requisito de plan | Free tier disponible | Plan pago de Cursor requerido |
La combinación más poderosa, al menos en papel, es la de JetBrains: te quedás con el refactoring, el debugger y el soporte de frameworks de JetBrains, y le sumás los modelos y capacidades agénticas de Cursor. El trade-off es que algunas features nativas de Cursor — como Tab completions en tiempo real — pueden no funcionar exactamente igual a través del protocolo ACP.
Para un desarrollador Java que vive en IntelliJ, la decisión es obvia: Cursor vía ACP. Para alguien que ya usa Cursor standalone y no tiene apego a JetBrains, probablemente no haya razón suficiente para migrar.
ACP como estándar abierto: qué significa para el ecosistema de desarrollo
El ACP Registry está activo desde enero de 2026 con agentes verificados disponibles para instalación directa. Cursor es el más visible, pero no el único. Cualquier proveedor de agentes de IA puede implementar el protocolo y aparecer en el registro.
Lo interesante es lo que esto implica a mediano plazo: se elimina el vendor lock-in entre agentes e IDEs. Si mañana aparece un agente de IA que supera a Cursor en alguna tarea específica — digamos, generación de tests o migración de código — podés instalarlo desde el mismo registry sin cambiar de editor. Y si JetBrains no te convence para un proyecto específico, el mismo agente funciona en cualquier otro IDE que implemente ACP.
El paralelo más claro es lo que LSP (Language Server Protocol) hizo por los language servers. Antes de LSP, cada editor necesitaba su propia implementación de autocompletado, navegación de código y diagnósticos para cada lenguaje. LSP estandarizó esa comunicación. ACP busca hacer lo mismo con agentes de IA. Si te interesa, podes leer mas sobre la integración de Copilot con GPT-5.4.
Eso sí, un estándar es tan bueno como su adopción. Que JetBrains y Zed lo co-desarrollen le da peso, pero falta ver si VS Code (Microsoft) y otros editores lo adoptan o si crean su propio protocolo competidor. Por ahora, el ecosistema es prometedor pero temprano.
Si querés profundizar en cómo evolucionan los IDEs con IA, mirá Cursor llega a JetBrains IDEs con protocolo ACP y MCP Apps i.
Mirá Cursor llega a JetBrains IDEs con protocolo ACP y MCP Apps i si querés entender mejor cómo evolucionan estas integraciones.
Qué significa para empresas y equipos en Latinoamérica
Para equipos de desarrollo en la región, hay dos puntos relevantes. Primero: muchas consultoras y empresas de software en Argentina, Colombia y México tienen sus stacks armados sobre JetBrains. Migrar a VS Code solo para tener IA no era una opción realista cuando tenés 50 desarrolladores con licencias Ultimate y workflows establecidos. ACP elimina esa barrera.
Segundo: el acceso multi-modelo es especialmente útil cuando los costos importan. Podés usar modelos más económicos para tareas simples (autocompletado, documentación) y reservar los modelos frontier para tareas complejas (refactoring de arquitectura, debugging). Esa flexibilidad permite optimizar el gasto en IA por desarrollador.
El tema de los Team Marketplaces también aplica: equipos distribuidos entre Buenos Aires, Medellín y São Paulo pueden estandarizar sus herramientas de IA desde un solo dashboard, sin depender de que cada dev configure todo manualmente.
Errores comunes
Creer que Cursor en JetBrains es idéntico al standalone
No lo es. El cliente standalone de Cursor es un fork completo de VS Code con todas las features integradas nativamente: Tab completions, edición inline, composer, terminal inteligente. Cuando usás Cursor vía ACP en JetBrains, accedés a las capacidades agénticas y a los modelos, pero algunas features específicas como el autocompletado en tiempo real pueden comportarse distinto o no estar disponibles. Antes de asumir paridad total, probalo con tu flujo de trabajo habitual. Si te interesa, podes leer mas sobre el control remoto de Claude Code.
Pensar que ACP reemplaza a MCP
Son protocolos complementarios, no competidores. ACP define cómo un agente de IA se comunica con un IDE. MCP define cómo un agente accede a herramientas y fuentes de datos externas (APIs, bases de datos, servicios). Un agente como Cursor usa ACP para conectarse a JetBrains y MCP para conectarse a Amplitude, Figma o tldraw. Confundirlos lleva a malentendidos sobre qué problema resuelve cada uno.
Instalar Cursor vía ACP sin plan pago y esperar que funcione
La integración con JetBrains requiere un plan pago de Cursor (Pro, Teams o Enterprise). Si instalás el agente desde el ACP Registry con una cuenta gratuita, vas a poder autenticarte pero las funcionalidades van a estar limitadas o directamente bloqueadas. Verificá tu plan antes de invertir tiempo en la configuración.
Preguntas Frecuentes
¿Cómo uso Cursor dentro de IntelliJ o PyCharm?
Abrí tu IDE de JetBrains, buscá el selector de agentes y accedé al ACP Registry. Desde ahí instalás Cursor como agente verificado y te autenticás con tu cuenta. Necesitás un plan pago de Cursor; no hay costo adicional por la integración con JetBrains.
¿Qué es el Agent Client Protocol (ACP)?
ACP es un estándar abierto co-desarrollado por JetBrains y Zed Industries que define cómo los agentes de IA se comunican con editores de código. Funciona de forma análoga a lo que LSP hizo para los language servers: cualquier agente compatible puede conectarse a cualquier IDE que implemente el protocolo, sin integraciones custom.
¿Qué modelos de IA puedo usar con Cursor en JetBrains?
Tenés acceso a modelos de OpenAI (GPT-4o, o-series), Anthropic (Claude Sonnet y Opus), Google (Gemini) y los modelos propios de Cursor optimizados para código. Podés elegir el modelo según la tarea: modelos rápidos para completado, modelos de razonamiento para debugging complejo.
¿Qué son las MCP Apps y qué puedo hacer con ellas?
Las MCP Apps (introducidas en Cursor 2.6) permiten que los servidores MCP rendericen interfaces interactivas directamente dentro del chat del agente. En la práctica, esto significa ver charts de Amplitude, diagramas de Figma o whiteboards de tldraw sin salir del editor. No son capturas estáticas: el agente puede leer e interpretar esas interfaces como contexto para sus respuestas.
Conclusión
Cursor dentro de JetBrains no es solo un plugin más. Es la primera implementación visible de un estándar (ACP) que puede cambiar cómo se distribuyen las herramientas de IA para desarrollo. Si usás IntelliJ, PyCharm o WebStorm, ya no tenés que elegir entre tu IDE preferido y las capacidades agénticas de Cursor.
Las MCP Apps agregan otra capa: la posibilidad de que el agente no solo procese texto sino que interactúe con interfaces visuales. Todavía es temprano para saber qué tan bien funcionan en la práctica diaria, pero la dirección es clara.
Si estás en un equipo que usa JetBrains, lo que conviene hacer ahora es probar la integración con uno o dos desarrolladores antes de hacer un rollout completo. Verificá que las features que más usás — indexación, chat contextual, MCP Apps — funcionen bien con tus proyectos reales. Y seguí de cerca la evolución del ACP Registry: si más agentes se suman, la competencia va a beneficiar a todos los que ya estén en el ecosistema.