Abres tu editor e inicias una sesión. Antes de que escribas nada, antes incluso de que el cursor se asiente en el campo de entrada, el agente ya ha leído una cantidad considerable. Ha absorbido su prompt de sistema, las definiciones de cada herramienta que puede invocar, sus instrucciones de comportamiento, el CLAUDE.md de tu proyecto (o .cursorrules, o AGENTS.md), cualquier regla acotada a rutas que corresponda y todo lo que haya en su archivo de memoria. Para cuando dices tu primera palabra, el agente ya tiene un modelo de ti, de tu proyecto y de cómo se supone que debe comportarse.
El modelo mental ingenuo es: tú escribes, el agente responde. La secuencia real es: el agente lee tu contexto, tú escribes, el agente responde. Ese primer paso silencioso, el agente leyéndote antes de que hables, decide una parte sorprendentemente grande del resultado. Y la evidencia sobre si el contexto que le das ayuda de verdad es más incómoda de lo que la mayoría supone.
La versión corta
- Los agentes de codificación con IA cargan contexto preescrito antes de tu primer mensaje: prompts de sistema, definiciones de herramientas y archivos de instrucciones propios de cada herramienta, como CLAUDE.md, las reglas de Cursor, las instrucciones de GitHub Copilot o AGENTS.md donde esté soportado o importado. La conversación no la inicias tú, la inicia la lectura del agente.
- Esa precarga se come una parte importante de la ventana de contexto utilizable antes de que hayas escrito un solo carácter, así que tu presupuesto real de trabajo es menor de lo que sugiere la ventana anunciada del modelo.
- El hallazgo empírico es la parte contraintuitiva: los archivos de contexto escritos por desarrolladores ayudan un poco (alrededor de +4 % de éxito en las tareas) a un coste real (alrededor de +19 % de coste de inferencia), mientras que los archivos de contexto generados por un LLM o copiados y pegados pueden hacer que los resultados sean ligeramente peor.
- Alojar tu propio modelo cambia lo que puedes ver, no lo que tiene que do. La arquitectura de pre-sesión es la misma en todas partes; las herramientas locales solo te permiten inspeccionarla y auditarla. La disciplina de escribir contexto que realmente entiendes no desaparece.
El modelo ingenuo es incorrecto: el agente lee primero
Imagina el momento exacto en que arranca una sesión de Claude Code. Entra el prompt del sistema. Entran las definiciones de herramientas. Después, antes de que hayas dicho nada, se entrega tu CLAUDE.md, y aquí el detalle mecánico importa. La propia documentación de Anthropic dice explícitamente que El contenido de CLAUDE.md se «envía como un mensaje de usuario después del prompt del sistema,» cargado “al inicio de cada conversación.” Así que el primer turno del usuario en la transcripción no eres tú. Es tu archivo, hablando en tu nombre, estableciendo los términos antes de que llegues.
Lo que realmente se carga en ese momento inicial es una pila: el prompt de sistema, las definiciones de herramientas, las instrucciones de comportamiento, tus archivos de contexto de proyecto y de usuario, cualquier regla acotada a rutas que coincida con los archivos en juego y un archivo de memoria que el propio agente mantiene. En Claude Code, los archivos de contexto se resuelven mediante una jerarquía de cuatro niveles (política gestionada, luego usuario (~/.claude/CLAUDE.md), luego proyecto (./CLAUDE.md), luego local (./CLAUDE.local.md)), concatenados en ese orden. La memoria automática añade su propia porción: las primeras 200 líneas (o 25KB) de un MEMORY.md que el agente escribe y lee por su cuenta, cargado en cada sesión.
Nada de esto es gratis. La sobrecarga de infraestructura (prompt de sistema, definiciones de herramientas, instrucciones de comportamiento) consume una parte considerable de la ventana de contexto efectiva antes de que llegue tu primer mensaje. Ese es el impuesto que pagas por que el agente sepa ser un agente, y es invisible a menos que lo busques.
Está surgiendo un nombre en torno a la disciplina de gestionar todo esto. El equipo de IA aplicada de Anthropic lo llama ingeniería de contexto: “el conjunto de estrategias para curar y mantener el conjunto óptimo de tokens (información) durante la inferencia de un LLM”. Es un término útil porque replantea el archivo que escribes: deja de ser una nota para el robot y pasa a ser una decisión arquitectónica sobre qué ocupa un recurso escaso y caro.
Cuatro agentes, cuatro formas de leerte primero
Los agentes no te leen todos de la misma manera. Se dividen en dos ejes que vale la pena nombrar: qué se carga al inicio de la sesión (una jerarquía organizada de archivos, frente a reglas siempre activas o un análisis completo del repositorio), y cuánto de eso puedes inspeccionar, es decir, si el mecanismo es un artefacto determinista y auditable o un índice semántico que tienes que aceptar por fe. En esos dos ejes es donde Claude Code, Cursor, GitHub Copilot y Aider divergen de verdad.
| Herramienta | Qué se carga al iniciar la sesión | Mecanismo | Auditabilidad |
|---|---|---|---|
| Claude Code | CLAUDE.md hierarchy + .claude/rules/ + memoria automática; AGENTS.md solo si se importa o enlaza simbólicamente | Jerarquía basada en archivos; las reglas con ámbito de ruta pueden cargarse de forma diferida; el comportamiento de compactación y relectura varía | Alto para tus archivos y memoria; el prompt del sistema sigue siendo propietario |
| Cursor | Reglas de proyecto, equipo y usuario; compatibilidad con AGENTS.md; índice de base de código para contexto semántico | Archivos de reglas legibles más indexación semántica del código base | Mixto: las reglas son legibles, pero la recuperación del índice es menos transparente |
| GitHub Copilot | En todo el repositorio copilot-instructions.md más los específicos por ruta .instructions.md donde sea compatible | Archivos de instrucciones personalizadas aplicados en los flujos de trabajo de Copilot | Moderado: los archivos son legibles, pero el alcance depende de la superficie del producto |
| Aider | Un repo-map compacto derivado del repositorio git, más archivos añadidos/leídos manualmente | Mapa de repositorio basado en símbolos/grafos optimizado para un presupuesto de tokens | Alta: el repo-map puede inspeccionarse, pero sigue siendo un mapa seleccionado, no el repositorio completo palabra por palabra |
La división de Cursor es la más instructiva. Sus reglas viven en archivos legibles que tú controlas, pero también construye una índice semántico de toda tu base de código, embeddings vectoriales que potencian la búsqueda @codebase y que no se pueden inspeccionar realmente. Aider se encuentra en el otro extremo: lee todo tu repositorio git y construye un repo-map, de forma determinista, sin embeddings por ningún lado. Puedes auditar exactamente qué le pasó al modelo. La misma inversión arquitectónica, con una visibilidad muy distinta sobre ella. Para la comparación detallada herramienta por herramienta, hemos cubierto el panorama de las CLI agénticas en nuestro duelo de CLI de codificación agéntica y se han enfrentado directamente en OpenCode vs Claude Code en otro lugar.
Por debajo de los formatos propios de cada herramienta, se está consolidando un estándar común. AGENTS.md surgió en el ecosistema de herramientas de agentes (OpenAI Codex, Amp, Jules de Google, Cursor y Factory) y ahora está administrado por la Agentic AI Foundation bajo la Linux Foundation, adoptado en más de 60 000 repositorios. Es el archivo de contexto previo a la sesión ascendiendo de comodidad de una sola herramienta a artefacto portátil de primera clase: la industria acepta que “lo que el agente lee antes de que hables” merece su propio estándar.
Lo que dice la evidencia sobre si algo de esto ayuda
Aquí es donde la historia cómoda se rompe. Un equipo de ETH Zurich (Gloaguen, Mündler, Müller, Raychev y Vechev) realizó una evaluación controlada, “Evaluando AGENTS.md,” sobre si estos archivos de contexto a nivel de repositorio mejoran realmente el rendimiento de los agentes de codificación. En todos los agentes y modelos que estudiaron, el resultado no fue «los archivos de contexto funcionan» ni «los archivos de contexto fallan». El resumen actual dice que los archivos de contexto no mejoran en general el éxito de las tareas y aumentan el coste de inferencia en más de un 20 % de media. En los resultados detallados del artículo, los archivos aportados por desarrolladores fueron la excepción: mejoraron el rendimiento en torno a un 4 % de media, pero incrementaron el coste hasta un 19 %. Los archivos generados por un LLM fueron en la dirección equivocada: redujeron el rendimiento cerca de un 3 % de media mientras elevaban el coste más de un 20 %. Un tercer hallazgo lo afina: los agentes llaman a una herramienta entre 1,6 y 2,5 veces más a menudo cuando esa herramienta se menciona en un archivo de contexto, algo que ayuda o perjudica dependiendo por completo de si esas llamadas extra estaban justificadas.
Detente un segundo en la línea de los archivos generados por LLM, porque es la que sostiene todo lo demás. Un archivo que no escribiste tú, ya sea generado por un modelo o descargado de un pack comunitario de «las mejores configuraciones de CLAUDE.md» y soltado en tu repositorio, le suena al agente a instrucciones de alguien que en realidad no conoce tu base de código. En los modelos del estudio, eso fue un saldo negativo: pagabas más tokens por resultados algo peores. El análisis de Augment Code sobre esto lo resume bien cuando llama al resultado acumulado “el cajón de sastre del contexto de tu agente”. Cada instrucción de aspecto plausible que echas dentro tiene un coste, y las que no escribiste tú, para una base de código que no entienden, suelen costar más de lo que devuelven.
No leo esto como «los archivos de contexto son malos» ni como «los archivos de contexto son buenos». Esos son justo los encuadres de todo o nada que se deshacen al contacto con los datos. La lectura más estrecha es esta: el contexto es infraestructura que diseñas de forma deliberada, y un archivo que no escribiste, para una base de código que no entiende, es un coste y no un regalo. La advertencia sobre el alcance también importa. Esto es lo que el artículo encontró para los modelos y agentes que probó, no una ley universal sobre todo LLM. Pero apunta con fuerza en una dirección, y está corroborado desde el lado del proveedor: el propio equipo de IA aplicada de Anthropic ha señalado el giro hacia cargar el contexto «justo a tiempo» mediante herramientas en tiempo de ejecución, en lugar de precargarlo todo por adelantado, y describe un enfoque híbrido que recupera algunos datos por adelantado y explora el resto en tiempo de ejecución. Cuando la empresa que publica CLAUDE.md se inclina por precargar menos, el instinto de copiar y pegar un archivo de contexto gigante merece una segunda mirada.
Conclusión de la sección: la autoría es la señal que predice si el contexto merece la pena. El coste en tokens es el mismo en cualquier caso; lo que cambia el retorno es si las instrucciones vienen de alguien que conoce de verdad el código.
El contexto que se desvanece: por qué el inicio de sesión no es toda la historia
La precarga establece la restricción. No la mantiene. Con lo que los desarrolladores tropiezan una y otra vez es con la segunda mitad de la historia: el contexto que colocaste con cuidado al iniciar la sesión se erosiona a medida que la sesión avanza, y lo hace en silencio.
Una forma útil de visualizar esto proviene del enfoque del equipo de Mem0, que considera que un la ventana de contexto es RAM, no almacenamiento, efímera y acotada, no un lugar persistente donde vivan tus instrucciones. Carga algo al principio y estará ahí; sigue lo suficiente sin usarlo y se desvanece, igual que una variable que dejas de referenciar acaba sobrescrita. Ese es el mecanismo detrás de un patrón que los investigadores describen como degradación de instrucciones. Un estudio de 2026 por Gamage y colegas descubrió que las restricciones de omisión son especialmente frágiles: en un escenario probado, el cumplimiento cayó del 73 % en el turno 5 a alrededor del 33 % en el turno 16. Es un hallazgo de laboratorio, no una constante universal, pero coincide con lo que mucha gente percibe en las sesiones largas.
El límite de sesión es donde se vuelve más claro. Desarrolladores en una discusión de Hacker News informan de que los subagentes generados pueden sufrir problemas de traspaso de contexto, así que el trabajo delegado a mitad de tarea puede llegar con menos contexto de la sesión padre del que suponías. Y el tiempo de inactividad tiene su propio coste: en un hilo donde Boris Cherny de Anthropic intervino, la discusión explica cómo una sesión inactiva puede desencadenar una reconstrucción enorme por fallo de caché, cientos de miles de tokens, sin ningún aviso para ti. El hilo conductor que la comunidad repite es el silencio: la compactación se ejecuta, el razonamiento previo se recorta, la calidad baja y nada en pantalla te dice que ocurrió. Solo notas que la salida empeoró.
¿El alojamiento propio te da más control?
Ejecuta todo tú mismo (Ollama más Open WebUI, o un agente como Aider o Continue.dev apuntando a un modelo local) y la respuesta honesta a «¿tengo ahora más control?» es: obtienes más visibilidad, no más control inherente. Esa distinción es el punto central.
Lo que el autoalojamiento te da de verdad es inspección. Ningún dato de conversación sale de tu infraestructura. Puedes leer el prompt de sistema completo en lugar de aceptar uno propietario por fe. Con una herramienta determinista como Aider, puedes auditar exactamente qué entró en cada llamada al modelo: el repo-map es un artefacto legible, no una caja negra semántica como el índice de embeddings de Cursor. Para quien le importa la auditabilidad y la reproducibilidad, poder responder a «¿qué vio realmente el agente?», esa capacidad de inspección es real y no es poca cosa.
Pero a la inversión arquitectónica le da igual dónde se ejecute el modelo. Ya uses un modelo local mediante Ollama, Claude Code contra una API en la nube o Cursor por suscripción, el agente sigue leyendo su contexto de presesión antes de que hables, y tú sigues teniendo que diseñar ese contexto de forma deliberada. La disciplina es idéntica. Alojarlo tú mismo te da una ventana más clara al mecanismo; no te da un mecanismo distinto, y desde luego no te libra de la lección de ETH Zurich sobre lo que pasa cuando cargas contexto que no escribiste. Así que el único cambio que merece la pena llevarse de todo esto: deja de tratar el archivo de contexto como un regalo que le entregas al agente y empieza a tratarlo como infraestructura con un coste recurrente. Escribe lo que de verdad entiendes del código, carga menos en vez de más, y recuerda que el agente te leyó primero, así que la versión de ti que leyó debería ser una que puedas defender.
Preguntas frecuentes
¿Los agentes de codificación con IA leen tus archivos antes de que escribas algo?
Sí. Al inicio de la sesión, un agente de programación con IA carga su prompt de sistema, sus definiciones de herramientas y tus archivos de contexto (CLAUDE.md, .cursorrules o AGENTS.md), junto con cualquier repo-map o archivo de memoria, todo antes de tu primer mensaje. En Claude Code en concreto, el CLAUDE.md se entrega como un mensaje de usuario justo después del prompt de sistema, así que la conversación empieza en la práctica con tu archivo y no contigo.
¿Los archivos de contexto como CLAUDE.md realmente mejoran el rendimiento del agente?
En parte, y menos de lo que la mayoría de la gente asume. En el Evaluación de ETH Zurich de los archivos de estilo AGENTS.md, el resumen actual dice que los archivos de contexto por lo general no mejoran el éxito en las tareas y aumentan el coste de inferencia más de un 20 % de media. Los resultados detallados son más útiles para quien trabaja a diario: los archivos aportados por desarrolladores mejoraron el rendimiento alrededor de un 4 % de media, pero elevaron el coste hasta un 19 %, mientras que los archivos generados por un LLM redujeron el rendimiento cerca de un 3 % de media y subieron el coste más de un 20 %. La lectura práctica: un archivo que escribiste y entiendes puede ayudar un poco; un archivo que no escribiste puede costarte caro sin que lo notes.
¿Cuánto de la ventana de contexto se usa antes de enviar un mensaje?
Una parte considerable. El prompt de sistema, las definiciones de herramientas y las instrucciones de comportamiento se cargan antes de cualquier entrada del usuario y, juntos, consumen una porción apreciable de la ventana de contexto efectiva. Tu presupuesto de trabajo utilizable es menor que la ventana de contexto anunciada del modelo por culpa de esa carga fija de arranque.
¿El alojamiento propio de un modelo de IA te da más control sobre el contexto?
Más visibilidad, no más control intrínseco. Autoalojar te permite inspeccionar el prompt de sistema completo, mantiene los datos de conversación en tu propia infraestructura y (con una herramienta determinista como Aider) te deja auditar exactamente qué entró en cada llamada. Pero la arquitectura de contexto previo a la sesión es la misma que en las herramientas en la nube, y sigues teniendo que diseñar tu contexto de forma deliberada.
¿Qué es AGENTS.md?
AGENTS.md es un formato abierto para indicar a los agentes de código cómo trabajar con una base de código: el equivalente de un README dirigido al agente. Surgió en todo el ecosistema de herramientas para agentes (OpenAI Codex, Amp, Jules de Google, Cursor y Factory) y ahora lo administra la Agentic AI Foundation bajo la Linux Foundation, con adopción en más de 60.000 repositorios, lo que lo convierte en el estándar entre herramientas que está surgiendo para el contexto del agente previo a la sesión.
