Se il vostro agente AI dà una risposta utile oppure si inventa qualcosa con assoluta sicurezza, dipende prima di tutto dalla gestione del contesto — da come la cronologia delle conversazioni, gli output degli strumenti e le conoscenze esterne vengono compressi nella finestra di contesto finita del modello. Prima di OpenClaw 2026.3.7, questa logica era hardcoded. Ora è un plugin.
Il Problema
OpenClaw usava una compattazione a finestra scorrevole: la conversazione si allungava troppo, i messaggi vecchi venivano riassunti, quelli nuovi trovavano spazio. Funzionava. Ma aveva i suoi compromessi, e non tutti erano contenti:
- •La sintesi perde dettagli. Un agente di programmazione deve fare riferimento a una funzione di 50 turni fa? Sparita.
- •Nessuna memoria tra le sessioni. Chiudi la sessione, perdi il contesto. Ogni conversazione riparte da zero.
- •Una strategia sola, prendere o lasciare. Vuoi un assembly basato su RAG? Ramificazione delle conversazioni? Budget di token personalizzati? Nessun modo pulito per farlo.
La gente si arrangiava — monkey-patching sugli internals, fork del core, orchestrazione esterna. Niente di sostenibile.
ContextEngine: Uno Slot Plugin per la Gestione del Contesto
La versione 2026.3.7 prende l'intero ciclo di vita del contesto, lo estrae in un'interfaccia ben definita e lo espone come plugin slot. Scrivi un plugin, implementa l'interfaccia, e la gestione del contesto è tua.
Come si integra
Registra la tua engine tramite la plugin API:
// In your plugin's bootstrap
export default function myContextPlugin(api: PluginAPI) {
api.registerContextEngine('my-engine', (config) => {
return new MyCustomContextEngine(config);
});
}
Selezionala nel config:
plugins:
slots:
contextEngine: my-engine
Nessun plugin configurato? OpenClaw incapsula il vecchio comportamento in un LegacyContextEngine. Per chi già lo usava, non cambia nulla.
Sette Hook del Ciclo di Vita
L'interfaccia mette a disposizione sette hook — uno per ogni fase che conta in un turno di conversazione:
1. `bootstrap()`
L'engine si avvia. Connettiti al tuo vector DB, costruisci il grafo, carica lo stato salvato.
async bootstrap(): Promise<void> {
this.vectorStore = await connectToVectorDB(this.config.dbUrl);
this.sessionGraph = new DAG();
}
2. `ingest(message: Message)`
Arriva un nuovo messaggio — input dell'utente, risposta dell'assistente, output di uno strumento. Decidi tu come archiviarlo e indicizzarlo.
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`
Il pezzo forte. Prima di ogni chiamata al modello, OpenClaw ti consegna un budget di token e chiede: costruiscimi un contesto. Quello che restituisci è esattamente ciò che il modello vedrà.
Engine diverse, strategie radicalmente diverse:
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()`
Il contesto ha sfondato il limite hard di token. È ora di snellire. L'engine di default riassume i messaggi vecchi. Il tuo plugin potrebbe potare nodi del grafo, scaricare su un vector store, o anche non fare niente se assemble() resta già nel budget.
5. `afterTurn(turn: Turn)`
Un turno completo è finito — l'utente ha parlato, l'agente ha risposto. Buon momento per persistere lo stato, aggiornare gli indici o avviare lavori in background.
6. `prepareSubagentSpawn(parentContext: Context): SubagentContext`
L'agente sta generando un subagente. Quanto contesto dare al figlio? Tutto gli farebbe sfondare il budget di token. Niente lo lascerebbe al buio. Questo hook ti permette di essere chirurgico.
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)`
Il subagente ha finito. I suoi risultati devono rientrare nel contesto del padre in qualche modo — merge completo, riassunto, selezione mirata. Decidi tu.
Architettura: Slot vs. Hook
ContextEngine è uno slot, non un hook. Gli hook sono additivi — dieci plugin possono ascoltare onMessage contemporaneamente. Gli slot sono esclusivi. Una sola ContextEngine alla volta.
┌─────────────────────────────────────┐
│ Plugin Registry │
│ │
│ Hook (additivi): │
│ onMessage → [plugin1, plugin2] │
│ onTool → [plugin3] │
│ │
│ Slot (esclusivi): │
│ contextEngine → my-engine │
│ (default: LegacyContextEngine) │
└─────────────────────────────────────┘
All'avvio, OpenClaw legge plugins.slots.contextEngine, trova la factory registrata e la istanzia. Se l'engine non esiste, l'avvio fallisce rumorosamente. Nessun fallback silenzioso — scelta deliberata. Devi sapere quale context engine sta girando.
L'isolamento dei subagenti usa AsyncLocalStorage: ogni figlio ottiene il proprio runtime con scope separato. Lo stato dei plugin non trapela oltre i confini degli agenti.
Cosa Stanno Già Costruendo
Lossless-Claw
GitHub · Martian Engineering
Il primo plugin serio per ContextEngine. Sostituisce la compattazione a finestra scorrevole con un sistema di sintesi basato su DAG che conserva ogni messaggio originale restando nei limiti di token.
- •Ogni messaggio diventa un nodo in un grafo aciclico diretto
- •I nodi si raggruppano in "episodi" per argomento
- •Budget superato? Gli episodi vecchi vengono riassunti, ma gli originali restano nel grafo
- •Se un turno successivo fa riferimento a contenuti vecchi, l'engine recupera l'originale — non il riassunto
Se vi è mai capitato che un agente di codice si dimenticasse una funzione scritta un'ora prima, ecco la soluzione.
MemOS Cloud Plugin
GitHub · MemTensor
Fa una cosa sola: dà al vostro agente una memoria che sopravvive tra le sessioni.
- •Al
bootstrap(): recupera i ricordi rilevanti da MemOS Cloud in base al messaggio di apertura - •Al
afterTurn(): salva i nuovi turni nel cloud - •All'
assemble(): inietta i ricordi recuperati nel contesto di sistema
Il vostro agente ricorda la conversazione della settimana scorsa, le vostre preferenze, i vostri progetti. Basta ripetersi.
Cosa Bolle in Pentola
Dalle issue su GitHub e dal Discord, la community sta lavorando su:
- •Assembly nativo con RAG: Niente cronologia messaggi, contesto assemblato da chunk di documenti recuperati. OpenClaw come motore di ricerca conversazionale.
- •Memoria condivisa multi-agente: Più agenti che condividono un knowledge graph. Workflow collaborativi senza contesto ridondante.
- •Ottimizzazione del budget di token: Composizione del contesto che si adatta dinamicamente al modello in uso — prezzo, punti di forza, lunghezza del contesto.
- •Ramificazione delle conversazioni: Contesto a struttura ad albero. Esplora percorsi diversi, torna indietro, tieni tutto.
Perché Cambia le Carte in Tavola
OpenClaw ha sempre saputo aggiungere canali, modelli e strumenti. Ma il contesto — il modo in cui l'agente effettivamente ragiona — era blindato dentro il core. Non si poteva toccare senza fare un fork.
ContextEngine scardina quel vincolo. E una volta aperto, gli effetti si moltiplicano:
- 1.Gli sviluppatori di plugin possono finalmente competere sul problema più difficile della UX degli agenti: la qualità del contesto.
- 2.Gli utenti enterprise ottengono controlli di compliance — redazione prima che il modello veda i dati, politiche di retention, audit di ogni prompt.
- 3.I ricercatori possono testare nuove strategie di contesto senza mantenere un fork.
- 4.I provider di modelli possono distribuire plugin ottimizzati per le loro architetture. Modelli a contesto lungo e corto non dovrebbero usare la stessa strategia.
Ecco cosa significa davvero quando un framework diventa una piattaforma. Non un rebrand. Non un post sul blog che annuncia una "visione." Un cambiamento architetturale concreto che rende l'ecosistema auto-rinforzante. Più plugin → più utenti → più sviluppatori → più plugin. Una volta che il ciclo parte, è difficile fermarlo.
L'aragosta ha appena messo una chela nuova.