Cómo lograr que tu asistente de IA "recuerde" — entre computadoras, entre personas… y entre agentes

Una técnica simple con Git y un enlace simbólico que empieza resolviendo un problema cotidiano y termina abriendo la puerta a algo mucho más grande: agentes de IA que colaboran entre sí sin un humano en el medio.

Si trabajás con asistentes de IA para programar —como Claude Code, Copilot u otros—, seguramente te topaste con el mismo problema que nosotros: cada vez que abrís una sesión nueva, la IA arranca en blanco. No recuerda las decisiones que tomaste ayer, los errores que ya resolviste, ni las convenciones particulares de tu proyecto.

Es como tener un compañero de equipo brillante pero con amnesia: cada mañana hay que explicarle de nuevo cómo funciona todo. En un proyecto real, eso es tiempo perdido y errores repetidos.

En este artículo compartimos una técnica sencilla que resuelve el problema. Y —esto es lo interesante— la vamos a llevar hasta una posibilidad que cambia por completo cómo puede trabajar un equipo… incluso cuando parte del equipo no es humano.

El problema de la memoria "local"

La mayoría de los asistentes de IA para desarrollo guardan su "memoria" o su contexto en una carpeta oculta de tu computadora. Funciona bien... mientras trabajes siempre en esa misma máquina, vos solo, y nunca la formatees.

Pero el desarrollo real casi nunca es así:

• Tenés una notebook para la calle y una de escritorio en la oficina.
• Programás en una máquina y probás en otra.
• Cambiás de computadora y perdés todo el contexto acumulado.
• Trabajás en equipo, y cada persona tiene su propia versión de la "memoria".

La solución: versionar la memoria junto con el código

La idea central es simple, y quizás por eso funciona tan bien: si el código ya se sincroniza con Git entre todas tus máquinas, ¿por qué no hacer lo mismo con la memoria de la IA?

Los pasos, en concepto:

1. Se crea una carpeta —por ejemplo memoria/— dentro del repositorio Git del proyecto.
2. Ahí se guardan notas por tema: cómo se compila, errores conocidos y cómo se resolvieron, decisiones de arquitectura, qué partes del sistema no hay que tocar, convenciones del equipo.
3. Mediante un enlace simbólico (symlink), se conecta esa carpeta del repositorio con el lugar donde el asistente de IA busca su memoria local.

El resultado: todo lo que la IA "aprende" y anota queda dentro del proyecto, versionado como un archivo más. Y viaja a todas partes con un simple git pull.

¿Qué se gana? Empecemos por lo cotidiano

Antes de llegar a lo ambicioso, veamos el valor inmediato, el que sentís desde el primer día.

1. Continuidad entre tus propias máquinas

Empezás algo en la notebook por la mañana, seguís en la máquina de escritorio por la tarde, y la IA tiene exactamente el mismo contexto en ambas. Nada que reexplicar.

2. Un mismo cerebro para todo un equipo

Imaginá un equipo distribuido: un desarrollador en Rosario, otro en Madrid, otro en la India. Con este esquema, todos comparten la misma memoria de proyecto: las mismas notas sobre cómo compilar, los mismos errores ya documentados, las mismas convenciones.

Cuando el programador de la India resuelve un bug complicado a las 3 de la mañana (su mañana), lo deja anotado. Cuando vos abrís el proyecto al día siguiente en Rosario, tu asistente ya lo sabe. No hay que preguntarle a nadie, no hay que esperar a que se despierte, no hay conocimiento atrapado en la cabeza de una sola persona.

Es, en esencia, la "memoria colectiva" de un equipo —ese saber tácito de "cómo se hacen las cosas acá"— pero escrita, versionada y accesible para todos.

Cuando el equipo incluye agentes autónomos

Hasta acá hablamos de personas que usan IA como herramienta. Pero las herramientas de IA para desarrollo están evolucionando hacia algo distinto: agentes que ejecutan tareas de forma autónoma —escriben código, corren pruebas, corrigen errores— con supervisión humana, pero sin que alguien tenga que dictarles cada paso.

Y acá la memoria compartida deja de ser una comodidad para volverse infraestructura crítica. Te lo mostramos con un caso real de nuestro taller.

Montamos dos estaciones de trabajo:

• En una, un agente de IA programa: escribe funciones, resuelve tareas, hace commits.
• En la otra, un segundo agente prueba: compila, ejecuta el sistema, verifica que todo funcione y reporta lo que encuentra.

Las dos estaciones no se hablan directamente. No hay un cable ni un mensaje entre ellas. Lo único que las conecta es la memoria compartida versionada en Git.

El flujo es casi poético: el primer agente termina una función de madrugada, la documenta en la memoria compartida y hace push. El segundo agente, en la otra máquina, hace pull, lee qué cambió, lo prueba, anota el resultado y hace push de vuelta. El primero se entera en su siguiente ciclo. Dos inteligencias artificiales coordinándose sobre un mismo proyecto, a través de una memoria común, sin un humano traduciendo entre ellas.

La memoria compartida se convierte en el lugar de encuentro de los agentes: el pizarrón donde uno deja anotado lo que el otro necesita saber. Es lo que transforma dos herramientas aisladas en algo parecido a un equipo.

Las ventajas concretas

• Historial completo: como es Git, sabés quién anotó qué y cuándo —sea persona o agente—. Podés volver atrás si algo se documentó mal.
• Sobrevive a los desastres: si una computadora se rompe o se formatea, la memoria sigue a salvo en el repositorio.
• Cero herramientas nuevas: usa Git, que tu equipo ya usa. No hay que aprender ni pagar nada extra.
• Revisable: cada anotación —humana o de un agente— puede revisarse antes de aceptarse. Vos tenés el control.
• Onboarding instantáneo: una persona nueva —o un agente nuevo— clona el repositorio y arranca sabiendo todo el contexto desde el minuto cero.
• Trabajo 24 horas: con agentes en distintas máquinas y husos horarios, el proyecto puede avanzar mientras dormís, dejando todo documentado para tu revisión.

Seamos honestos: los límites y los cuidados

Toda técnica tiene su letra chica, y con los agentes autónomos hay que ser especialmente honesto —porque es un tema donde sobra el humo—. Estos son los cuidados reales:

• El humano no desaparece, decide: los agentes ejecutan, pero el criterio, la dirección y la aprobación final siguen siendo de las personas. "Autónomo" no es "sin supervisión". Un agente puede avanzar rápido en la dirección equivocada.
• Los agentes también se traban: se quedan pegados en un problema, malinterpretan una instrucción, o repiten un error. La memoria compartida ayuda, pero no los hace infalibles.
• Cuidado extremo con la información sensible: la memoria no debe contener nunca contraseñas, claves ni datos privados. Todo lo que entra al repositorio queda en su historial —y si algún día se hace público, queda expuesto. La regla de oro: si es un secreto, no va en la memoria versionada.
• Disciplina de sincronización: el sistema depende de hacer pull antes y push después. Si se rompe esa disciplina, los agentes trabajan con información desactualizada.
• La memoria envejece: una nota vieja que ya no aplica puede confundir tanto a una persona como a un agente. Hay que mantenerla, como cualquier documentación.

La conclusión

Empezamos con un problema pequeño —una IA que se olvidaba de todo— y terminamos en algo que hace unos años sonaba a ciencia ficción: agentes de inteligencia artificial colaborando entre sí sobre un mismo proyecto, coordinados por una memoria común.

Y la técnica que lo hace posible no es un producto caro ni una plataforma exótica. Es Git —una herramienta que existe hace veinte años— usada con un poco de imaginación.

Esa es, para nosotros, la clave: trabajar bien con inteligencia artificial no es solo pedirle cosas. Es armarle el contexto para que sea un buen colaborador, y darle un lugar donde ese contexto viva, se comparta y crezca —entre máquinas, entre personas y, cada vez más, entre agentes—.

En Pronexo trabajamos todos los días en esto: encontrar la forma más simple —y más honesta— de que la tecnología, incluida la IA, trabaje para las personas, no al revés.