Cómo migrar de Manus a Cursor sin perder el contexto (2026)

Tus Skills, casi sin cambios. Este es el punto principal. Una Skill de Manus es un SKILL.md más "recursos opcionales incluidos, como scripts de Python, documentos de referencia o plantillas", y Manus las exporta como "archivos .skill, archivos .zip o enlaces directos a repositorios de GitHub". Cursor detecta automáticamente las skills al inicio desde cuatro directorios: .agents/skills/ y .cursor/skills/ para el ámbito del proyecto, ~/.agents/skills/ y ~/.cursor/skills/ para el ámbito del usuario; y su documentación añade una línea que vale la pena conocer: "Por compatibilidad, Cursor también carga skills desde los directorios de Claude y Codex: .claude/skills/, .codex/skills/, ~/.claude/skills/ y ~/.codex/skills/".

Así que el desempaquetado consiste simplemente en copiar en una carpeta. Ambas partes describen incluso el mismo comportamiento de carga: las Skills de Manus utilizan la "'Divulgación Progresiva' para gestionar de manera eficiente la ventana de contexto del agente", y la lista de propiedades de skills de Cursor incluye "Progresivo: las skills cargan recursos bajo demanda, manteniendo eficiente el uso del contexto".

Las instrucciones de tu proyecto, como contenido. Cualquier directriz a nivel de proyecto que tuvieras en Manus se convierte en un archivo AGENTS.md en la raíz del repositorio o en un archivo .cursor/rules. Las reglas de Cursor son archivos .mdc cuyo frontmatter decide cuándo se aplican, describiéndose AGENTS.md en la documentación como una "alternativa simple a .cursor/rules".

Tus archivos, como archivos del repositorio. Cualquier cosa que Manus guardara como archivo de proyecto y que pertenezca a la base de código simplemente se confirma (commit). Esa es la parte menos interesante de la migración y en la que la gente suele pasar más tiempo.

Nada más. Aquí está la lista específica.

La base de conocimientos no tiene un contenedor en Cursor. Manus la limita estrictamente: "la base de conocimientos del usuario está limitada a 100 entradas para usuarios Pro y 50 entradas para usuarios Gratuitos". Cursor no tiene ningún almacén de conocimientos basado en entradas. Sus mecanismos de persistencia son reglas y skills: archivos que están siempre activos o que se invocan, no un conjunto de datos consultables. Lo que significa que las 40 u 80 entradas que acumulaste se reducen a prosa de reglas, o simplemente no se transfieren.

Vale la pena leer ese límite dos veces, porque también te indica para qué creía Manus que servía el contenedor. Su propio consejo cuando alcanzas el límite es "filtrar las entradas en tu base de conocimientos según tus necesidades más importantes y recientes, y eliminar algunas entradas innecesarias", y advierte que "tener demasiadas entradas puede afectar la calidad de respuesta del sistema". Cien entradas es un conjunto curado, no un archivo.

El historial de tareas no se traslada. Tu copia de seguridad de datos de tareas puede tener potencialmente decenas de gigabytes de ejecuciones pasadas. No existe una ruta de importación en Cursor para eso, ni tendría una forma útil si la hubiera. Es un registro, no contexto.

Los conectores MCP y las credenciales del proyecto se quedan atrás. Manus admite conectores con "credenciales compartidas a nivel de proyecto". Cursor también tiene MCP, pero estas son configuraciones por herramienta que debes reconstruir en lugar de migrar, y las credenciales deben volver a emitirse en lugar de copiarse a cualquier parte.

La invocación autónoma cambia de forma. En Manus, una Skill es la forma en que conviertes a "tu agente de un asistente de propósito general en un experto especializado". En Cursor, al agente "se le presentan las skills disponibles y decide cuándo son relevantes según el contexto", y también puedes invocar una escribiendo /. Un detalle a tener en cuenta: "Una skill invocada de esta manera se asocia a un solo mensaje. Para mantener una skill activa durante toda la sesión, úsala como un Modo Personalizado con Option+Enter (Mac) o Alt+Enter (Windows)". Los flujos de trabajo de Manus que se ejecutaban de principio a fin se convierten en skills que un agente de programación puede o no retomar a mitad de la tarea.

Aspectos a nivel de cuenta que debes manejar por separado. Manus señala que "el inicio de sesión con Facebook no estará disponible después del cambio de servicio" y que algunos usuarios "deben usar este archivo para restaurar sus cuentas en el futuro". Esas son tareas administrativas de la cuenta, no contexto, y no pertenecen a la misma sesión que tu migración.

Paso 1: Separa tu archivo en las tres cosas que contiene

Antes de copiar nada, clasifica. Casi todo el mundo intenta migrar el archivo como una unidad y se estanca, porque dos tercios del mismo no tienen destino.

Abre tu exportación y divídela en: Skills (los archivos .skill o archivos .zip, o los repositorios de GitHub a los que los subiste), entradas de la base de conocimientos (declaraciones fácticas breves sobre ti, tu trabajo, tus limitaciones) e historial de tareas (todo lo demás, la mayor parte de los bytes).

Manus ofrece un atajo para extraer las Skills limpiamente si aún no lo has hecho: pídele que "empaquete este flujo de trabajo como una Skill" y "generará el archivo SKILL.md necesario y cualquier script asociado". Si tienes un flujo de trabajo que solo existió como una conversación que repetías constantemente, así es como se convierte en un archivo portátil en lugar de un párrafo que tienes que volver a escribir.

Para exportaciones grandes, utiliza la ruta que recomienda Manus: "Recomendamos encarecidamente exportar directamente a Google Drive o OneDrive mediante autorización OAuth" en lugar de intentar mover decenas de gigabytes a través del correo electrónico o una descarga del navegador.

Lee las entradas de la base de conocimientos antes de decidir qué hacer con ellas. Con un máximo de 100 entradas en el plan Pro, esta es una lista que una persona puede leer en quince minutos, y son los quince minutos de mayor valor de toda la migración. También es la única parte que no está en un formato de archivo que otra herramienta pueda entender.

Paso 2: Instala las Skills, luego decide a dónde va el conocimiento

Coloca las Skills en un directorio que Cursor lea. Para las skills que pertenecen a un solo repositorio, colócalas en .agents/skills/<nombre>/SKILL.md y confírmalas (commit). Para las skills que quieras en todas partes, usa ~/.agents/skills/. Cursor las detecta al inicio, así que reinícialo después de copiarlas.

Si la exportación te dio un enlace de GitHub en lugar de un archivo, eso también funciona: las skills de Cursor se "almacenan como archivos y se pueden rastrear en tu repositorio, o instalar a través de enlaces de repositorios de GitHub".

Revisa la descripción del frontmatter de cada skill. Cursor decide su relevancia a partir de ella. Una skill de Manus cuya descripción asumiera un agente de propósito general ("gestiona solicitudes de investigación") rara vez se activará en una sesión de programación. Reescribe las descripciones con el vocabulario del trabajo que realmente vas a realizar.

Convierte las instrucciones del proyecto y elige un formato. Mantener AGENTS.md es la opción que no requiere trabajo y suele ser la correcta. Convierte a .cursor/rules solo cuando quieras una carga condicional: el frontmatter de .mdc te permite elegir entre Aplicar siempre (Always Apply), Aplicar inteligentemente (Apply Intelligently - "Cuando el agente decide que es relevante según la descripción"), Aplicar a archivos específicos (Apply to Specific Files) y Aplicar manualmente (Apply Manually).

Presta atención a la extensión mientras lo haces: "El sistema de reglas ignora un archivo .md simple en .cursor/rules porque no tiene frontmatter para especificar description, globs y alwaysApply. Si prefieres markdown simple, usa AGENTS.md en su lugar". Pegar tus instrucciones de Manus en esa carpeta como .md es la forma más silenciosa de migrar hacia la nada.

Y luego están las entradas de la base de conocimientos, que es donde la gente se estanca. Las propias directrices de Cursor desaconsejan el movimiento obvio. Su lista de cosas que se deben evitar en las reglas incluye "Duplicar lo que ya está en tu base de código", y sus mejores prácticas recomiendan "Hacer referencia a archivos en lugar de copiar su contenido; esto mantiene las reglas cortas y evita que se queden obsoletas a medida que cambia el código". Ochenta entradas de conocimiento pegadas en una regla siempre activa es un documento que se envía con cada solicitud, y Cursor recomienda mantener las reglas por debajo de las 500 líneas.

Si solo necesitas un puñado de ellas, conviértelas en reglas. Si tenías una base de conocimientos real, necesitan un contenedor real. Los mecanismos para lograr que las reglas se mantengan se detallan en llevar el contexto de Cursor a través de las sesiones, y la dirección opuesta (configuraciones con formato de Cursor que se trasladan) se encuentra en migrar de Claude Code a Cursor.

Mira lo que acaba de pasar. Tus Skills se trasladaron porque ambas herramientas coincidieron en un formato de archivo. Tu base de conocimientos no se trasladó porque Cursor no tiene ese contenedor, y el propio límite de 100 entradas de Manus te indica que tampoco estuvo pensada nunca para ser un archivo.

Esa es la verdadera lección de esta migración. Los procedimientos ahora son portátiles; el estándar Agent Skills resolvió eso. Los datos fácticos no lo son. Cada herramienta los almacena con una forma diferente, los limita a un número distinto y los pierde cuando la abandonas.

Eso es lo que MemoryLake conserva: tu conocimiento duradero en forma de entradas que puedes leer, corregir y eliminar, en una capa que tus herramientas consultan en lugar de un archivo que envían con cada solicitud. La configuración consta de tres pasos.

Paso 1: Crea una clave API

Inicia sesión en MemoryLake y crea una clave API. Una sola credencial para todas las herramientas que conectes.

Paso 2: Sube tus primeros recuerdos

Entradas cortas, una afirmación cada una. Tu base de conocimientos de Manus es tu material de origen, y ya tiene aproximadamente la forma adecuada:

Restricciones con el motivo adjunto. "Los informes se envían el jueves porque el cierre financiero se realiza el miércoles por la noche". Una instrucción establece la fecha límite; solo esto sobrevive si alguien la cuestiona.

Enfoques ya descartados, y por qué. La categoría que no cabe en ningún archivo de reglas y que cada nuevo agente vuelve a proponer.

Datos del entorno que nadie anuncia. La API que limita la tasa de solicitudes en un umbral no documentado, el conjunto de datos con un retraso de dos días, el cliente que no aceptará un PDF.

Tu propio contexto de trabajo. Rol, stack, convenciones: las entradas que un agente de propósito general solía conocer sobre ti y que un nuevo agente de programación no conoce.

Paso 3: Conecta tu IA y tus agentes

Conecta las herramientas que utilizas. Se puede acceder a MemoryLake a través de MCP y de una API, por lo que los agentes nativos de MCP (entre ellos Claude Code, Codex y OpenClaw) se conectan apuntando al servidor MCP, mientras que otros asistentes leen la misma memoria a través de la API. El efecto práctico es que el próximo cambio de herramienta será un cambio de configuración en lugar de una transferencia de conocimientos.

Tres límites honestos. MemoryLake no lee tu archivo de copia de seguridad de Manus ni importa tu historial de tareas: el Paso 1 sigue siendo una clasificación manual, y el archivo es un registro que debes guardar en un lugar seguro. Solo contiene lo que tú o tus agentes introducen en él, por lo que el Paso 2 es manual. Y no es un almacén de credenciales: los conectores y las credenciales a nivel de proyecto deben volver a emitirse en la nueva herramienta, no copiarse.

El archivo deja de ser un obstáculo. Una vez que sabes que dos tercios del mismo no tienen destino, la migración se convierte en una clasificación de quince minutos en lugar de una tarde de confusión.

Las Skills dejan de ser un trabajo específico de la herramienta. El mismo SKILL.md es leído por Cursor, Claude Code y Codex. Un flujo de trabajo que escribiste una vez ahora es tuyo.

Los límites de entradas dejan de ser tu techo. 100 entradas en el plan Pro era una función para forzar la curación, no una decisión de almacenamiento. Conserva la curación; elimina el techo.

Los archivos de reglas se mantienen cortos en la nueva herramienta. La razón por la que una regla crece es que está haciendo dos trabajos: guiar y recordar. Sepáralos y la recomendación de 500 líneas de Cursor dejará de importar.

"Aún no conoce mi trabajo" obtiene una respuesta real. No "escribe más reglas", sino "los datos fácticos nunca estuvieron en las reglas", el caso general que se explica en por qué RAG no es memoria.

Exporta las Skills como archivos antes que cualquier otra cosa. Son la parte que tiene un destino real, y los archivos .skill, .zip y los enlaces de GitHub funcionan.

Utiliza la ruta OAuth a Google Drive o OneDrive para exportaciones grandes. Manus lo recomienda específicamente porque los datos de tareas pueden alcanzar decenas de gigabytes.

Lee las entradas de tu base de conocimientos a mano. Con un máximo de 100, es una lista legible, y es la única parte que no tiene formato de archivo.

Reescribe las descripciones de las skills para el nuevo contexto. Cursor elige las skills por su descripción; una descripción escrita para un agente de propósito general no se activará en una sesión de programación.

Nunca dejes un archivo .md simple dentro de .cursor/rules. Se ignora silenciosamente. Utiliza .mdc con frontmatter, o AGENTS.md.

Prefiere .agents/skills/ para mayor portabilidad. Cursor, Claude Code y Codex leen skills de directorios que se superponen; elegir el compartido evita una segunda copia.

Reinicia Cursor después de copiar las skills. La detección ocurre al inicio.

Vuelve a emitir las credenciales en lugar de migrarlas. Las credenciales de los conectores de una plataforma que estás abandonando deben rotarse, no trasladarse.

Mantén los datos fácticos fuera de los archivos de reglas. Las reglas son dirección e indicadores; el razonamiento es lo que permite a un agente manejar el caso que no escribiste, el enfoque que se detalla en por qué los agentes ignoran los archivos de instrucciones que escribiste.

La migración de Manus a Cursor se divide claramente a lo largo de una línea que la mayoría de la gente no ve hasta que está a la mitad del camino. Las Skills se transfieren porque ambas herramientas implementan el estándar Agent Skills y ambas leen SKILL.md; Cursor incluso las carga desde .claude/skills/ y .codex/skills/ por compatibilidad, por lo que copiar una carpeta y reiniciar es realmente la mayor parte del trabajo. Las instrucciones del proyecto se convierten en AGENTS.md o .cursor/rules con una decisión de formato y una trampa de extensión.

Lo que no se transfiere es la base de conocimientos. Manus la limitaba a 100 entradas en el plan Pro y 50 en el Gratuito, y te recomendaba depurarla en lugar de ampliarla; Cursor no tiene ningún contenedor equivalente, y su propia documentación desaconseja pegar ese contenido en una regla siempre activa. El historial de tareas tampoco se traslada, ni debería hacerlo.

Así que clasifica el archivo en Skills, entradas e historial antes de copiar nada. Instala las Skills en .agents/skills/, convierte las instrucciones y coloca las entradas (las restricciones, los enfoques descartados, los datos fácticos que nadie anuncia) en algún lugar que tus herramientas puedan consultar. De este modo, la próxima migración será solo una copia de directorio y un cambio de configuración, que es lo que esta debería haber sido.