Por qué dos buenas herramientas terminan con dos memorias diferentes
Los mecanismos son simétricos pero no compatibles
La documentación de Cursor describe cuatro tipos de reglas: reglas de proyecto almacenadas como archivos .mdc en .cursor/rules, reglas de usuario globales para tu entorno de Cursor, reglas de equipo gestionadas desde el panel de control en los planes Team y Enterprise, y AGENTS.md como una alternativa markdown en la raíz del proyecto. La documentación de Claude Code describe CLAUDE.md en cuatro ámbitos: política gestionada, usuario (~/.claude/CLAUDE.md), proyecto (./CLAUDE.md o ./.claude/CLAUDE.md) y local (CLAUDE.local.md), además de .claude/rules/ para instrucciones con ámbito de ruta.
Alinea eso y tendrás dos sistemas casi paralelos que utilizan nombres de archivo diferentes, campos de frontmatter diferentes y reglas de carga diferentes. Ninguno lee el formato principal del otro. La documentación de Claude Code lo dice directamente: "Claude Code lee CLAUDE.md, no AGENTS.md".
Un archivo que leen ambas herramientas, y la forma documentada de conectarlo
Aquí está la parte que la mayoría de la gente pasa por alto. Cursor incluye AGENTS.md en la raíz del proyecto como un archivo de instrucciones compatible, con soporte para archivos AGENTS.md anidados en subdirectorios donde los más específicos tienen prioridad. Y la documentación de Claude Code ofrece la receta exacta para hacer que ese mismo archivo funcione de su lado: "Si tu repositorio ya utiliza AGENTS.md para otros agentes de codificación, crea un CLAUDE.md que lo importe para que ambas herramientas lean las mismas instrucciones sin duplicarlas".
Eso es un CLAUDE.md de una sola línea que contiene @AGENTS.md, o un enlace simbólico si no necesitas adiciones específicas de Claude. Ambas herramientas leen entonces un solo archivo. Este es un patrón documentado en ambos lados, no un truco.
Lo que el truco del archivo no puede cubrir
Dos cosas permanecen separadas sin importar cómo organices los archivos.
La memoria automática de Claude Code. Está activada por defecto, almacena notas en ~/.claude/projects/<project>/memory/, carga las primeras 200 líneas o 25 KB de MEMORY.md en cada sesión y es explícitamente local de la máquina; la documentación indica que los archivos "no se comparten entre máquinas o entornos en la nube". También está escrita por Claude en lugar de por ti. Cursor no tiene un equivalente para leerla, y ningún archivo que confirmes en el repositorio la haría visible.
Carga condicional. Los cuatro modos de aplicación de Cursor deciden cuándo entra una regla en contexto: alwaysApply: true, una description para aplicación inteligente, globs para archivos específicos o reglas manuales que requieren una mención con @. El .claude/rules/ de Claude Code utiliza un campo de frontmatter paths: para el mismo propósito. Ambos son lógicos, y significan que "contenido compartido" no implica "cargado en los mismos momentos".
MCP es el canal que ambas herramientas ya hablan
Sin embargo, hay una segunda cosa que ambas tienen en común además de AGENTS.md, y es la más interesante: ambas son compatibles con MCP. Claude Code documenta la configuración del servidor MCP como una característica de primer nivel, incluyendo definiciones de mcpServers en línea por subagente, y Cursor expone la configuración de MCP en sus propios ajustes.
Eso importa porque cambia lo que puede significar "compartir memoria". Un archivo compartido es estático: el mismo texto, cargado en ambos lados, actualizado a mano. Un servidor compartido es dinámico: ambas herramientas consultan el mismo almacén en el momento en que necesitan algo, y una escritura de una es visible para la otra en la siguiente lectura. Para el conocimiento que cambia a medida que trabajas (que es la mayor parte del conocimiento que importa), la segunda forma es la que realmente funciona.
También significa que no tienes que elegir un ganador entre los sistemas de memoria nativos de las dos herramientas. Claude Code conserva su memoria automática para el recuerdo local; Cursor conserva sus reglas para la carga condicional; y el conocimiento duradero del proyecto vive en un lugar al que ambos pueden acceder sin que ninguna de las dos herramientas tenga que entender el formato de la otra.
Y una trampa que vale la pena conocer antes de copiar nada. La documentación de Cursor dice: "El sistema de reglas ignora un archivo .md plano en .cursor/rules porque no tiene frontmatter para especificar description, globs y alwaysApply". Si mueves contenido y dejas un archivo markdown plano en ese directorio, silenciosamente no hará nada. Ese fallo específico se cubre en por qué Cursor olvida las reglas del proyecto.
Lo que la gente intenta
Mantener dos archivos con el mismo contenido. El método por defecto, y funciona durante unas dos semanas. Luego alguien actualiza uno, y ahora las herramientas no están de acuerdo, sin errores y sin un diff que notar, porque ambos archivos parecen actualizados.
Hacer que ambos archivos sean enormes. Si el archivo es el único canal, todo va en el archivo. Ambos proveedores lo desaconsejan: Cursor dice que mantengas las reglas por debajo de las 500 líneas y dividas las grandes en piezas combinables; Claude Code recomienda apuntar a menos de 200 líneas por archivo y señala que los archivos más largos "consumen más contexto y reducen la adherencia".
Sincronizar `~/.claude` entre máquinas. Algunas personas sincronizan todo el directorio de configuración para solucionar el hecho de que la memoria automática sea local de la máquina. Es una solución alternativa de los usuarios, no una característica documentada, y conlleva un riesgo real de escrituras conflictivas. Trátalo como un experimento, no como una configuración definitiva.
Ejecutar `/init` y darlo por terminado. Útil y poco utilizado: el /init de Claude Code lee las reglas de Cursor de .cursor/rules/ o .cursorrules e incorpora las partes relevantes en el CLAUDE.md generado, y con CLAUDE_CODE_NEW_INIT=1 también lee AGENTS.md, .devin/rules/, .windsurf/rules/ y .clinerules. Pero es una copia única, no un enlace. Una vez que se ejecuta, los dos archivos comienzan a distanciarse de nuevo. Lo mismo ocurre con /import, que trae la configuración de un agente compatible y traslada los servidores MCP, comandos, subagentes y habilidades: una migración, no una sincronización. Si deseas realizar ese movimiento unidireccional correctamente, migrar las reglas de Cursor a Claude Code lo cubre.
Aceptar el costo. El resultado más común: la gente simplemente vuelve a explicar. Cuesta tokens en cada mensaje y cuesta lo que realmente te importa, que es que la segunda herramienta tome decisiones sin saber lo que aprendió la primera.
La solución: un archivo compartido, una capa de memoria compartida
Divide el problema en dos y ambas mitades se vuelven sencillas.
Las reglas que deben estar en contexto cada vez pertenecen a un archivo confirmado en el repositorio. Usa AGENTS.md como el contenido real y un CLAUDE.md de una sola línea que lo importe. Mantenlo corto: las reglas que defenderías en una revisión de código, no una base de conocimientos.
El conocimiento que crece pertenece a una capa de memoria que ambas herramientas consultan. Eso es lo que es MemoryLake: un almacén, accesible por ambos agentes, que contiene las decisiones y restricciones que de otro modo vivirían en el directorio de memoria privado de una herramienta. La configuración consta de tres pasos.
Paso 1: Crear una clave API
Inicia sesión en MemoryLake y crea una clave API. Una sola credencial para ambas herramientas, que es todo el propósito: la credencial no está vinculada al editor en el que te encuentres hoy.
Paso 2: Sube tus primeras memorias
Comienza con lo que sigues explicando una y otra vez: decisiones de arquitectura y el razonamiento detrás de ellas, restricciones que parecen arbitrarias sin contexto, convenciones que viven en la cabeza de las personas y los enfoques que probaste y rechazaste. Si Claude Code ha estado acumulando memoria automática, abre ese directorio y léelo: los hechos duraderos que hay allí son exactamente el material al que Cursor nunca ha tenido acceso. Mantén las entradas cortas y de un solo tema para que la recuperación devuelva algo útil.
Paso 3: Conecta tu IA y agentes
Conecta ambas herramientas. MemoryLake es accesible a través de MCP y de una API, por lo que los agentes nativos de MCP (Claude Code, Codex y OpenClaw entre ellos) se conectan apuntando al servidor MCP, y Cursor se conecta a través de su propia configuración de MCP. A partir de ese momento, las dos herramientas leen el mismo conocimiento, y una decisión registrada mientras se trabaja en una está disponible en la otra. Para obtener una guía paso a paso del lado de MCP en general, consulta configurar la memoria entre IAs con MCP.
Dos límites honestos. Esto no fusiona los sistemas de memoria propios de las dos herramientas: Claude Code seguirá escribiendo su memoria automática local de la máquina, y eso está bien; es buena para recordar el trabajo local reciente. And no es una capa de cumplimiento: ambos proveedores describen las instrucciones como contexto en lugar de configuración, por lo que cualquier cosa que deba cumplirse independientemente de lo que decida un modelo pertenece a un hook o a una verificación de CI.
Qué cambia esto en la práctica
Una corrección, ambas herramientas. La victoria concreta. Hoy en día, decirle a Cursor "ya no usamos ese ORM" le enseña exactamente a una herramienta. Cuando la corrección llega a una capa compartida, la otra también deja de proponerlo.
Las transferencias dejan de perder contexto. El flujo de trabajo común es explorar en una herramienta y ejecutar en la otra. Esa transferencia es donde ocurre la reexplicación, y es el punto que elimina una capa compartida, algo más cercano a lo que hace compartir contexto entre sesiones de Claude Code dentro de una herramienta, pero extendido a dos.
Ambos archivos de instrucciones se vuelven más cortos. Una vez que el conocimiento de referencia es recuperable, AGENTS.md puede ser la lista corta que se suponía que debía ser, lo que mejora notablemente la confiabilidad con la que se sigue.
El límite de la máquina deja de importar tanto. Que la memoria automática sea local de la máquina significa que la mitad de tu conocimiento acumulado vive en una sola computadora. Una capa compartida no cambia ese mecanismo, pero significa que las partes importantes no están solo allí, resolviendo el problema descrito en evitar que Cursor olvide entre máquinas.
Agregar una tercera herramienta es solo una conexión. Cualquier herramienta que adoptes a continuación leerá la misma memoria en lugar de comenzar desde cero y otra semana de explicaciones repetitivas.
Buenas prácticas para ejecutar ambas herramientas en un solo repositorio
Un archivo real, un puntero. AGENTS.md contiene el contenido; CLAUDE.md contiene @AGENTS.md y, opcionalmente, una sección corta específica de Claude debajo. Nunca dos copias completas.
Mantén los globs alineados. Cuando los globs de una regla de Cursor y los paths: de una regla de Claude Code describen el mismo conjunto de archivos, puedes revisarlos como un par. Cuando se desvían, las reglas específicas de un área se aplican en una herramienta y no en la otra.
Nunca pongas un `.md` plano en `.cursor/rules`. Se ignora silenciosamente. El contenido sin frontmatter pertenece a AGENTS.md.
Ejecuta `/init` una vez, deliberadamente. Es un buen punto de partida para un CLAUDE.md y lee tus reglas existentes de Cursor y Copilot. Solo no lo confundas con una sincronización continua.
Verifica qué se cargó después de cualquier reestructuración. Claude Code enumera los archivos de memoria cargados en la sesión a través de /context. Confirma antes de concluir que un modelo te está ignorando; esa distinción es la diferencia entre una solución de cinco minutos y una semana de ajuste de prompts, como se explica en por qué Claude Code olvida el contexto del proyecto.
Escribe los rechazos, no solo las decisiones. La categoría de mayor valor. Ambas herramientas volverán a proponer aquello que ya descartaste a menos que la decisión esté escrita donde puedan leerla.
Conclusión
El costo de usar dos herramientas tiene dos componentes y requieren soluciones diferentes. Las reglas que siempre están activas realmente pueden ser un solo archivo: Cursor lee AGENTS.md, y la propia documentación de Claude Code te indica que lo importes desde un CLAUDE.md de una sola línea. Haz eso esta tarde y habrás eliminado el problema de la desviación para la capa que más importa con frecuencia.
Lo que un archivo no puede hacer es compartir el conocimiento que se acumula, porque del lado de Claude Code esa capa es local de la máquina y autoescrita, y del lado de Cursor está gobernada por condiciones de frontmatter. Coloca esa mitad en una capa de memoria que ambas herramientas consulten, y la transferencia entre la edición y el trabajo de agentes dejará de ser el lugar donde tu contexto va a morir.