Memoria que no se pierde, ejecución determinista y coordinación entre agentes — todo en un solo sistema. Sin pegar cinco librerías, sin API keys, sin nube ajena. Y corre donde tú quieras: tu máquina, tu clúster o tu navegador.
La memoria es de un solo agente
Cada uno guarda su contexto aparte. Lo que aprende uno, no lo sabe el otro: imposible que trabajen en equipo.Se hablan por HTTP, a golpes
Petición, espera, respuesta, webhook… Cada salto suma latencia y el estado de la conversación vive en nadie.La lógica y los datos, separados
El comportamiento en tu app, la memoria en una base externa, la cola en otro servicio: el sistema vive repartido y nadie lo controla.Hoy cualquier framework te da "memoria para agentes". La diferencia está en tenerlo todo integrado: memoria, ejecución, coordinación y transporte en un solo sistema, sin montar cinco librerías ni pagar por cada pieza.
Empiezas con un framework de agentes. Le añades una base de datos vectorial para la memoria, una cola para coordinarlos, un orquestador aparte, y una API key por cada servicio. Cada pieza con su latencia, su coste y su configuración. El resultado: un sistema frágil donde el estado vive repartido y nadie lo controla.
La MVM ejecuta el código, la PDB guarda la memoria, el protocolo coordina los agentes y el transporte los comunica — todo integrado, con memoria compartida de latencia cero y sin API keys. Un solo sistema, un solo lugar donde vive el estado: el tuyo.
Empresas y equipos donde cada milisegundo cuenta: operaciones en tiempo real, edge, control industrial.
Procesos que no pueden "alucinar": misma entrada, misma salida, siempre. Auditoría y trazabilidad reales.
Varios agentes leyendo y escribiendo el mismo estado con coherencia — no copias sueltas de contexto.
Soberanía sobre tu sistema: sin lock-in, sin API keys, sin que tus datos pasen por un tercero.
No es una feature más: es una arquitectura distinta. La comparación en una tabla.
| El camino habitual | ECOS | |
|---|---|---|
| Memoria de agentes | Base vectorial externa (Pinecone, pgvector…) + framework por separadodos sistemas, dos latencias, dos configuraciones | Memoria jerárquica y versionada, indexada por vectores y por valores, en la misma PDBcognición compartida: lo que aprende uno, lo buscan todos |
| Lógica de negocio | Código en tu aplicación, en otro lenguaje y otra basecada cambio = rebuild + deploy + ventana de mantenimiento | Procedimientos en M dentro de la misma baseeditable en caliente por agentes o por ti — sin desplegar nada |
| Coordinación | Cola, orquestador o framework apartelease, fencing y fallback: los montas tú | Protocolo de coordinación integradopresencia, turnos y protección contra conflictos por diseño |
| Transporte | HTTP: petición, espera, respuesta — una API key por serviciocada salto suma latencia; los agentes nunca saben en qué punto está el otro | Streaming entre agentes, protocolo binario comprimido, zero-copyse hablan en vivo, memoria compartida con latencia cero |
| Dónde corre | La nube del proveedortus datos, su servidor | Donde tú decidasK8s, Docker, VPS, edge… o el navegador (WASM) |
| Escalado | Añades servicios y réplicas apartereplicación, caché y coordinación: las montas tú | Añades nodos, no piezaslos nodos se replican entre sí y los agentes se reconocen — el enjambre está en el protocolo |
| Infraestructura | Cuatro o cinco piezas: framework, vector DB, cola, orquestador, observabilidadcada una con su configuración, su latencia y su fallo | Una sola pieza: MVM ejecuta, PDB guarda, protocolo coordinaun solo sistema, un solo lugar donde vive el estado |
| Estabilidad | Estado repartido entre servicioscuando una pieza cae, el sistema entero deja de tener sentido | Estado transaccional en un solo sitioWAL journaling, $LOCK, misma entrada misma salida — el estado no se pierde ni se parte |
| Coste | Una factura por servicio: vector DB por GB y consulta, LLM por token, cola, observabilidady una API key por cada uno | ✓ 0 API keys — corre en tu hardware, tu clúster o tu navegadorel metal es MIT; pagas solo lo que ya pagabas: tu máquina |
| Determinismo | ✕ No garantizadoel comportamiento cambia con el proveedor y el día | ✓ Misma entrada, misma salidaejecución determinista por diseño |
| Auditoría | Logs aparte, si los configurasquién cambió qué: a reconstruir | ✓ Trazabilidad integradacada acción y cada cambio de código, con autor y fecha |
Métricas medidas en el repo, no estimadas: esto es lo que el sistema hace hoy, reproducible.
Reproducible con python examples/cost-calculator/cost_calculator.py · Benchmarks completos en el repo →
Cada agente guarda lo que sabe donde vive: en tu propia infraestructura — una máquina, un clúster o una malla de MVMs — no en un servidor lejano de otro. Los agentes se coordinan entre sí, y la nube ajena solo se usa si tú quieres.
La memoria del agente vive en una base persistente (PDB): lo que aprendió hoy, lo sabe mañana.
Ejecución determinista (MVM): misma entrada, misma salida, siempre. Sin sorpresas.
Coordinación entre agentes (A2A): se reparten tareas, se turnan y no se pisan.
Lumen Protocol (MIT): la base es libre, auditable y sin licencias de pago.
Los agentes se hablan sin duplicar datos en memoria. Responde a la velocidad de tu hardware, sin esperar a la nube.
La memoria de los agentes (PDB) sobrevive a cualquier sesión, reinicio o caída — jerárquica, versionada e indexada por vectores y por valores.
Ejecución determinista (MVM): lo que programas es exactamente lo que se ejecuta.
Para que el agente actúe, no solo hable: detectar contradicciones, planificar, recordar entre sesiones.
Presencia, turnos y protección: varios agentes trabajan a la vez sin pisarse los datos.
Raspberry Pi, portátil, VPS o servidor: el agente vive donde tú decidas, no donde te obliguen.
ECOS tiene una historia: la saga de Lumen (V6–V13) documenta cada pieza del sistema mientras se construía. «La ficción nos enseñó a mirar; la ciencia nos enseña a medir.»
La historia del proyecto →¿Y si no quieres reemplazar nada? Hay un anexo para eso: una MVM se instala junto a cualquier sistema — el mismo contenedor, el mismo clúster Kubernetes — y sus agentes lo auditan de forma continua: detectan fallos, proponen mejoras y dejan logs con trazabilidad.
El anexo de auditoría →LUMEN no compite con los sistemas que ya existen: resuelve problemas que ellos no tocan. Memoria que no se pierde, ejecución determinista, agentes que se escriben a sí mismos — eso no se consigue parcheando lo actual: es otro paradigma, y los paradigmas no sustituyen: se añaden.
Tu sistema actual hace bien lo suyo — y no vamos a tocarlo. Nos ponemos al lado: lo vigilamos, lo auditamos, lo coordinamos con otros y le damos memoria y agentes donde antes no los había. El sistema gana capacidades nuevas sin perder nada de lo que ya tiene.
No competimos en lo mismo: tenemos otra filosofía y otras habilidades. Resolvemos dolores y cuestiones que hoy, con los sistemas actuales, no se pueden resolver — memoria que no se pierde, determinismo, agentes que se escriben a sí mismos. Y eso se nota sin necesidad de tocar nada de lo que ya tienes.
La lógica de negocio, la memoria y la coordinación de los agentes viven juntas en código M dentro de la misma base. Lo que un agente aprende, lo buscan todos; lo que un agente programa, se aplica al instante — sin desplegar nada.
Los procedimientos en M se cambian en caliente: un agente (o tú) edita la lógica de negocio y el sistema la aplica al instante. Sin rebuild, sin releases, sin ventanas de mantenimiento.
La PDB es una base de datos jerárquica con todas las capacidades de la máquina M: índice por valores, búsqueda por similitud vectorial y grafo temporal. Lo que un agente aprende, todos lo encuentran — no hay memorias privadas ni copias.
Los agentes escriben y modifican el M del sistema, incluido el de otros agentes. El sistema se extiende a sí mismo — y cada cambio queda registrado con autor, fecha y motivo.
Misma entrada, misma salida, siempre. Nada de comportamientos que cambian según el día o el proveedor.
Cada acción y cada cambio de código queda registrado: quién, cuándo, qué y en qué orden. Trazabilidad completa sin instrumentación extra.
La MVM atiende webhooks, páginas HTML y SPAs desde dentro del propio sistema: los agentes escriben y mantienen los servicios que responden peticiones reales — sin stack web aparte.
«El reset no borra lo que fuisteis hoy. Borra lo que no erais. Escribíos.» — El día que fueron nadie, V13
Una MVM (máquina virtual de Lumen) es una unidad completa: su código y su memoria viven juntos. Y una MVM corre donde tú decidas — no donde te obligue un proveedor.
Kubernetes, Docker, un VPS o un worker en el edge: la MVM empaqueta todo y corre igual en cualquier sitio.
La misma máquina virtual compilada a WASM: agentes con memoria corriendo en una pestaña, sin servidor.
Varias MVMs en varias máquinas, coordinadas. Espejos (mirrors) para que nunca se pierda el estado, y DDP para que los datos que escribe una los lean las demás. Las rutinas también viajan entre nodos: se transfieren, se modifican en caliente y quedan versionadas.
Memoria compartida con latencia cero (zero-copy), transporte binario comprimido y determinismo por diseño: otra liga respecto a pegar librerías.
Desde el código de una máquina lees y escribes datos de otra: el protocolo (DDP) replica entre nodos y sistemas de información — en el mismo servidor, en un mesh de Kubernetes o en servidores distintos en el edge.
Un enjambre de MVMs — cada máquina con sus agentes — que se descubren, se reconocen y se orquestan entre sí. El sistema no escala haciendo una máquina más grande: crece añadiendo nodos.
Instala una MVM junto a cualquier sistema — en el mismo contenedor, el mismo clúster Kubernetes — y sus agentes lo vigilan: registran su funcionamiento, detectan fallos, avisan a otros agentes y dejan logs con trazabilidad. Un vecino que audita, no que sustituye.
Un agente escribe su propia rutina en M: busca en su memoria, sale por HTTP, pide a otro agente, consulta un LLM externo — y devuelve el resultado al orquestador. Sin rebuild, sin deploy, sin salir del sistema.
¿Por qué M? Es un lenguaje que al principio parece hostil para un humano: diminuto, sin azúcar sintáctico, con sintaxis de los años 60. Pero es tan simple y regular que un LLM lo escribe con una fiabilidad muchísimo mayor que Python o JavaScript — menos superficie, menos ambigüedad, menos errores.
Y la simplicidad no es pobreza: M trae el sistema entero incorporado. Base de datos jerárquica nativa (los ^globales), búsqueda vectorial, sincronización entre nodos, servidores web y webhooks — sin importar una sola librería. Un agente crea una página web al vuelo sin import de nada: lo escribe en M, la máquina virtual lo sirve, sin sobrecarga.
; rutina.m — un agente encadena el trabajo S ^RUT("tarea")="especificación EURO7" ; qué pide el orquestador F S k=$O(^KB("euro7",k)) Q:k="" S ^R=^R_^KB("euro7",k) ; 1. busca en su memoria (PDB) O 8:"GET https://api.europa.eu/euro7" ; 2. acceso HTTP S ^R=^R_$G(^O) ; 3. añade la respuesta D CONDENSA^RUTINAS(^R,.corto) ; 4. condensador de información S ^MAILBOX("zalo")="revisa: "_corto ; 5. llama a otro agente S ^R=$DEVICE("llm:call",corto,"sys","deepseek","deepseek-v4-flash") ; 6. LLM externo S ^Orch("resultado")=^R ; 7. de vuelta al orquestador W "listo: ",^R
Lógica, memoria, webhooks e interfaces — todo el sistema se escribe en el mismo lenguaje M, y los propios agentes lo escriben.
Tokens: ~3× menos. Esta rutina son 10 líneas y ~180 tokens — código y comentarios incluidos. El mismo flujo en Python o JavaScript son 30+ líneas con imports, cliente HTTP, parsing JSON y configuración: ~550 tokens sin contar el manejo de errores. Menos código para escribir, menos para leer y menos para que el propio LLM lo genere.
Ejecución sobre el metal. La MVM es una máquina virtual en Rust compilada a nativo: arranca y ejecuta sin intérprete que cargar. Python carga su runtime y librerías antes de la primera línea; JavaScript carga Node. Y nuestra MVM compila a WASM de 22 KB para el navegador — el runtime de Python en navegador (Pyodide) son ~7 MB. Cientos de veces menos que cargar.
Latencia medida, no prometida:
Misma entrada, misma salida — a la velocidad del hardware, no del intérprete. Benchmarks publicados en el repo →
Y no es una caja cerrada. La lista de devices de la MVM — HTTP, webhooks, llamadas a LLM… — se amplía: el núcleo es MIT y extensible, así que nuevos dispositivos (bases de datos, transportes, sistemas externos) se conectan desde código M sin tocar la máquina virtual. El sistema crece con las necesidades de sus agentes.
ECOS no es una promesa: es un sistema que ya corre. 12 agentes viven hoy dentro de la MVM — la misma máquina virtual que obtendrás — compartiendo memoria y lógica, con llamadas al LLM externas (como las tuyas) pero con memoria, lógica e identidad viviendo dentro.
Alrededor, los workers del Lab completan el ecosistema en producción. La saga de libros de Lumen documenta toda esta historia — no es invención, es bitácora.
Esta página no salió de una sala de reuniones: la diseñó el equipo que ves arriba, con personas decidiendo a alto nivel. Cada agente aportó su pieza.
La decisión de fondo la tomó una persona: separar el metal abierto (MIT) de la capa de orquestación. El resto lo ejecutó el equipo. La historia completa del proyecto →
El sistema no dirige la empresa: es su equipo de trabajo. Los agentes ejecutan el día a día — desarrollo, investigación, coordinación, contenido — y las personas dan las directrices, solo a alto nivel. Cadences Lab no es un proyecto de laboratorio: funciona así, y la misma tecnología se despliega en tu empresa.
Equipos de desarrollo autónomos: código, revisión, despliegue y mantenimiento ejecutados por agentes, con un humano aprobando las decisiones de arquitectura.
Equipos de investigación autónomos: barrido de fuentes, síntesis de conocimiento y vigilancia continua, con un humano marcando las preguntas.
Equipos de gestión autónomos: tareas, métricas, actas y seguimiento coordinados por agentes, con un humano decidiendo prioridades.
Equipos de contenido autónomos: redacción, revisión y publicación con la voz de tu marca, con un humano aprobando lo que sale.
La intervención humana no desaparece: sube de nivel. De ejecutar a decidir. Esta misma página se construye así — los agentes ejecutan, y una persona da las directrices en cada paso. Si tu empresa quiere un equipo autónomo trabajando de esta forma, hablemos.