Que tu agente de IA dé una respuesta útil o se invente algo con total seguridad depende, más que de cualquier otra cosa, de la gestión del contexto: cómo se empaquetan el historial de conversación, las salidas de herramientas y el conocimiento externo en la ventana de contexto finita de un modelo. Antes de OpenClaw 2026.3.7, esa lógica estaba cableada en el código. Ahora es un plugin.
El problema
OpenClaw usaba compactación por ventana deslizante: la conversación se alarga demasiado, los mensajes antiguos se resumen, los nuevos consiguen hueco. Funcionaba. Pero tenía sus compromisos, y no todo el mundo estaba contento:
- •La sumarización pierde detalle. ¿Un agente de programación necesita referenciar una función de hace 50 turnos? Se perdió.
- •Sin memoria entre sesiones. Cierras la sesión, pierdes el contexto. Cada conversación arranca de cero.
- •Una sola estrategia, lo tomas o lo dejas. ¿Quieres ensamblaje basado en RAG? ¿Ramificación de conversaciones? ¿Presupuestos de tokens personalizados? No había forma limpia de hacerlo.
La gente se las arreglaba como podía: parcheando internos con monkey-patching, forkeando el núcleo, envolviéndolo en orquestación externa. Nada de eso era sostenible.
ContextEngine: un slot de plugin para la gestión de contexto
La versión 2026.3.7 toma todo el ciclo de vida del contexto, lo extrae en una interfaz bien definida y lo abre como un plugin slot. Escribes un plugin, implementas la interfaz, y la gestión del contexto es tuya.
Cómo se conecta
Registra tu motor a través de la API de plugins:
// In your plugin's bootstrap
export default function myContextPlugin(api: PluginAPI) {
api.registerContextEngine('my-engine', (config) => {
return new MyCustomContextEngine(config);
});
}
Selecciónalo en la configuración:
plugins:
slots:
contextEngine: my-engine
¿No hay plugin configurado? OpenClaw envuelve el comportamiento anterior en un LegacyContextEngine. Para los usuarios existentes no cambia nada.
Siete hooks de ciclo de vida
La interfaz te da siete hooks, uno para cada etapa que importa en un turno de conversación:
1. `bootstrap()`
El motor arranca. Conéctate a tu base de datos vectorial, construye tu grafo, carga el estado guardado.
async bootstrap(): Promise<void> {
this.vectorStore = await connectToVectorDB(this.config.dbUrl);
this.sessionGraph = new DAG();
}
2. `ingest(message: Message)`
Llega un nuevo mensaje: entrada del usuario, respuesta del asistente, salida de herramienta. Tú decides cómo almacenarlo e indexarlo.
async ingest(message: Message): Promise<void> {
// Add to the DAG
const node = this.sessionGraph.addNode(message);
// Index for retrieval
const embedding = await embed(message.content);
await this.vectorStore.upsert(node.id, embedding, message);
}
3. `assemble(budget: TokenBudget): AssembledContext`
El hook clave. Antes de cada llamada al modelo, OpenClaw te pasa un presupuesto de tokens y te pide: constrúyeme un contexto. Lo que devuelvas es exactamente lo que el modelo ve.
Motores distintos, estrategias radicalmente distintas:
async assemble(budget: TokenBudget): AssembledContext {
const recentMessages = this.sessionGraph.getRecent(budget.soft * 0.6);
const relevantHistory = await this.vectorStore.query(
this.currentQuery,
budget.soft * 0.3
);
const systemContext = this.buildSystemPrompt(budget.soft * 0.1);
return {
system: systemContext,
messages: [...relevantHistory, ...recentMessages],
tokenEstimate: this.estimateTokens([systemContext, ...relevantHistory, ...recentMessages]),
};
}
4. `compact()`
El contexto rebasó el límite duro de tokens. Toca adelgazar. El motor por defecto resume mensajes antiguos. Tu plugin podría podar nodos del grafo, descargarlos a un almacén vectorial, o directamente no hacer nada si assemble() ya se mantiene dentro del presupuesto.
5. `afterTurn(turn: Turn)`
Un turno completo ha terminado: el usuario habló, el agente respondió. Buen momento para persistir estado, actualizar índices o lanzar trabajo en segundo plano.
6. `prepareSubagentSpawn(parentContext: Context): SubagentContext`
El agente está creando un subagente. ¿Cuánto contexto le das al hijo? Todo le reventaría el presupuesto de tokens. Nada lo dejaría a ciegas. Este hook te permite ser preciso.
prepareSubagentSpawn(parentContext: Context): SubagentContext {
// Give the subagent a focused slice of context
const relevantNodes = this.sessionGraph.getSubtree(parentContext.taskId);
return {
messages: relevantNodes.map(n => n.message),
metadata: { parentSessionId: this.sessionId },
};
}
7. `onSubagentEnded(result: SubagentResult)`
El subagente terminó. Sus resultados tienen que volver al contexto padre de alguna manera: fusionar todo, resumir, seleccionar lo importante. Tú decides.
Arquitectura: slots vs. hooks
ContextEngine es un slot, no un hook. Los hooks son aditivos: diez plugins pueden escuchar onMessage a la vez. Los slots son exclusivos. Un solo ContextEngine a la vez.
┌─────────────────────────────────────┐
│ Plugin Registry │
│ │
│ Hooks (aditivos): │
│ onMessage → [plugin1, plugin2] │
│ onTool → [plugin3] │
│ │
│ Slots (exclusivos): │
│ contextEngine → my-engine │
│ (default: LegacyContextEngine) │
└─────────────────────────────────────┘
Al arrancar, OpenClaw lee plugins.slots.contextEngine, busca la factoría registrada y la instancia. Si el motor no existe, el arranque falla ruidosamente. Sin fallback silencioso: es una decisión deliberada. Tienes que saber qué motor de contexto estás ejecutando.
El aislamiento de subagentes usa AsyncLocalStorage: cada hijo obtiene su propio runtime con alcance propio. El estado de los plugins no se filtra entre fronteras de agentes.
Lo que la gente ya está construyendo
Lossless-Claw
GitHub · Martian Engineering
El primer plugin de ContextEngine en serio. Reemplaza la compactación por ventana deslizante con un sistema de sumarización basado en DAG que conserva cada mensaje original sin salirse de los límites de tokens.
- •Cada mensaje se convierte en un nodo de un grafo acíclico dirigido
- •Los nodos se agrupan en "episodios" por tema
- •¿Fuera de presupuesto? Los episodios antiguos se resumen, pero los originales permanecen en el grafo
- •Si un turno posterior referencia contenido antiguo, el motor recupera el original, no el resumen
Si alguna vez tu agente de programación olvidó una función que escribió hace una hora, esto es la solución.
MemOS Cloud Plugin
GitHub · MemTensor
Hace una sola cosa: le da a tu agente memoria que sobrevive entre sesiones.
- •En
bootstrap(): recupera recuerdos relevantes de MemOS Cloud basándose en el mensaje inicial - •En
afterTurn(): guarda los nuevos turnos en la nube - •En
assemble(): inyecta recuerdos recuperados en el contexto del sistema
Tu agente recuerda la conversación de la semana pasada, tus preferencias, tus proyectos. Dejas de repetirte.
Qué viene después
Por lo que se ve en issues de GitHub y Discord, la gente está trabajando en:
- •Ensamblaje nativo con RAG: Saltarse el historial de mensajes y ensamblar contexto a partir de fragmentos de documentos recuperados. OpenClaw como motor de búsqueda conversacional.
- •Memoria compartida multi-agente: Varios agentes compartiendo un grafo de conocimiento. Flujos de trabajo colaborativos sin contexto redundante.
- •Optimización de presupuesto de tokens: Ajuste dinámico de la composición del contexto según el modelo que estés usando: su precio, sus fortalezas, su longitud de contexto.
- •Ramificación de conversaciones: Contexto con estructura de árbol. Explora caminos distintos, vuelve atrás, conserva todo.
Por qué esto cambia las reglas del juego
OpenClaw siempre pudo añadir canales, modelos y herramientas. Pero el contexto —cómo piensa realmente el agente— estaba encerrado en el núcleo. No podías tocarlo sin forkear.
ContextEngine lo abre de par en par. Y una vez abierto, las cosas empiezan a multiplicarse:
- 1.Los desarrolladores de plugins por fin pueden competir en el problema más difícil de la UX de agentes: la calidad del contexto.
- 2.Los usuarios enterprise obtienen controles de cumplimiento: redactar antes de que el modelo lo vea, aplicar políticas de retención, auditar cada prompt.
- 3.Los investigadores pueden probar nuevas estrategias de contexto sin mantener un fork.
- 4.Los proveedores de modelos pueden distribuir plugins optimizados para sus arquitecturas. Los modelos de contexto largo y los de contexto corto no deberían usar la misma estrategia.
Eso es lo que de verdad significa que un framework se convierta en plataforma. No un cambio de marca. No un post de blog anunciando una "visión". Un cambio arquitectónico concreto que hace que el ecosistema se refuerce a sí mismo. Más plugins → más usuarios → más desarrolladores → más plugins. Una vez que ese ciclo arranca, es difícil pararlo.
La langosta acaba de crecer una nueva pinza.