Of je AI-agent een bruikbaar antwoord geeft of vol zelfvertrouwen iets verzint, hangt meer dan wat dan ook af van contextbeheer—hoe gespreksgeschiedenis, tool-output en externe kennis worden ingepast in het beperkte contextvenster van een model. Vóór OpenClaw 2026.3.7 zat die logica hardcoded in de kern. Nu is het een plugin.
Het probleem
OpenClaw gebruikte sliding-window compaction: wordt het gesprek te lang, dan worden oude berichten samengevat om ruimte te maken voor nieuwe. Dat werkte. Maar het had nadelen, en niet iedereen was daar blij mee:
- •Samenvatten kost detail. Een coding agent die een functie van 50 beurten geleden nodig heeft? Weg.
- •Geen geheugen tussen sessies. Sessie sluiten betekent context kwijt. Elk gesprek begint op nul.
- •Eén strategie, slikken of stikken. RAG-gebaseerde assembly? Conversation branching? Eigen token-budgetten? Geen schone manier om dat te doen.
Mensen vonden workarounds—monkey-patching van interne code, de kern forken, er externe orchestratie omheen bouwen. Geen daarvan was houdbaar.
ContextEngine: een plugin slot voor contextbeheer
2026.3.7 pakt de hele context-lifecycle, definieert er een heldere interface voor, en maakt het beschikbaar als plugin slot. Schrijf een plugin, implementeer de interface, en contextbeheer is van jou.
Hoe het werkt
Registreer je engine via de plugin API:
// In your plugin's bootstrap
export default function myContextPlugin(api: PluginAPI) {
api.registerContextEngine('my-engine', (config) => {
return new MyCustomContextEngine(config);
});
}
Selecteer hem in de configuratie:
plugins:
slots:
contextEngine: my-engine
Geen plugin geconfigureerd? Dan wikkelt OpenClaw het oude gedrag in een LegacyContextEngine. Voor bestaande gebruikers verandert er niets.
Zeven lifecycle hooks
De interface geeft je zeven hooks—één voor elke fase die ertoe doet in een gespreksbeurt:
1. `bootstrap()`
De engine start op. Verbind met je vector DB, bouw je graph, laad opgeslagen state.
async bootstrap(): Promise<void> {
this.vectorStore = await connectToVectorDB(this.config.dbUrl);
this.sessionGraph = new DAG();
}
2. `ingest(message: Message)`
Er komt een nieuw bericht binnen—gebruikersinput, antwoord van de assistent, tool-output. Jij bepaalt hoe het wordt opgeslagen en geïndexeerd.
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`
De grote. Vóór elke model-aanroep krijg je een token-budget van OpenClaw met de vraag: bouw me een context. Wat je teruggeeft is exact wat het model ziet.
Verschillende engines, radicaal verschillende strategieën:
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()`
De context is over de harde tokenlimiet heen geschoten. Tijd om in te krimpen. De standaard engine vat oude berichten samen. Jouw plugin kan graph-nodes snoeien, offloaden naar een vector store, of het helemaal overslaan als assemble() al binnen budget blijft.
5. `afterTurn(turn: Turn)`
Een volledige beurt is klaar—de gebruiker sprak, de agent antwoordde. Goed moment om state op te slaan, indexes bij te werken of achtergrondwerk op te starten.
6. `prepareSubagentSpawn(parentContext: Context): SubagentContext`
De agent start een subagent. Hoeveel context krijgt het kind mee? Alles blaast het token-budget op. Niets maakt hem blind. Met deze hook kun je precies bepalen wat er meegaat.
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)`
De subagent is klaar. De resultaten moeten op de een of andere manier terug in de parent-context—alles mergen, samenvatten, cherry-picken. Jouw keuze.
Architectuur: Slots vs. Hooks
ContextEngine is een slot, geen hook. Hooks zijn additief—tien plugins kunnen allemaal naar onMessage luisteren. Slots zijn exclusief. Eén ContextEngine tegelijk.
┌─────────────────────────────────────┐
│ Plugin Registry │
│ │
│ Hooks (additief): │
│ onMessage → [plugin1, plugin2] │
│ onTool → [plugin3] │
│ │
│ Slots (exclusief): │
│ contextEngine → my-engine │
│ (default: LegacyContextEngine) │
└─────────────────────────────────────┘
Bij het opstarten leest OpenClaw plugins.slots.contextEngine, zoekt de geregistreerde factory, en instantieert hem. Bestaat de engine niet? Dan crasht het opstarten. Luid en duidelijk. Geen stille fallback—dat is een bewuste keuze. Je moet weten welke context engine je draait.
Subagent-isolatie gebruikt AsyncLocalStorage: elk kind krijgt zijn eigen scoped runtime. Plugin-state lekt niet over agent-grenzen heen.
Wat mensen nu al bouwen
Lossless-Claw
GitHub · Martian Engineering
De eerste serieuze ContextEngine-plugin. Vervangt sliding-window compaction door een DAG-gebaseerd samenvattingssysteem dat elk origineel bericht bewaart en toch binnen de tokenlimiet blijft.
- •Elk bericht wordt een node in een directed acyclic graph
- •Nodes clusteren in "episodes" op basis van onderwerp
- •Over budget? Oude episodes worden samengevat, maar de originelen blijven in de graph
- •Als een latere beurt oude content referenceert, haalt de engine het origineel op—niet de samenvatting
Als je ooit een coding agent hebt gehad die een functie vergat die hij een uur eerder schreef: dit is de oplossing.
MemOS Cloud Plugin
GitHub · MemTensor
Doet één ding: geeft je agent geheugen dat sessies overleeft.
- •Bij
bootstrap(): haalt relevante herinneringen op uit MemOS Cloud op basis van het openingsbericht - •Bij
afterTurn(): slaat nieuwe beurten op in de cloud - •Bij
assemble(): injecteert opgehaalde herinneringen in de systeemcontext
Je agent herinnert zich het gesprek van vorige week, je voorkeuren, je projecten. Je hoeft jezelf niet meer te herhalen.
Wat komt er aan
Op basis van GitHub issues en Discord werken mensen aan:
- •RAG-native assembly: Sla berichtgeschiedenis over, bouw context op uit opgehaalde documentfragmenten. OpenClaw als conversationele zoekmachine.
- •Multi-agent gedeeld geheugen: Meerdere agents die een knowledge graph delen. Samenwerken zonder overbodige context.
- •Token-budget optimalisatie: Dynamisch afstemmen van contextcompositie op het model dat je gebruikt—de prijs, de sterktes, de contextlengte.
- •Conversation branching: Boomstructuur-context. Verken verschillende paden, schakel terug, bewaar alles.
Waarom dit een gamechanger is
OpenClaw kon altijd al kanalen, modellen en tools toevoegen. Maar context—hoe de agent daadwerkelijk denkt—zat opgesloten in de kern. Je kon er niet aankomen zonder te forken.
ContextEngine breekt dat open. En zodra het open is, gaat het zich opstapelen:
- 1.Plugin-ontwikkelaars kunnen eindelijk concurreren op het moeilijkste probleem in agent UX: contextkwaliteit.
- 2.Enterprise-gebruikers krijgen compliance-controls—redacteren voordat het model het ziet, retentie afdwingen, elke prompt auditen.
- 3.Onderzoekers kunnen nieuwe contextstrategieën testen zonder een fork te onderhouden.
- 4.Model-providers kunnen plugins leveren die zijn afgestemd op hun architectuur. Long-context modellen en short-context modellen horen niet dezelfde strategie te gebruiken.
Dát is hoe een framework écht een platform wordt. Geen rebrand. Geen blogpost over een "visie." Een concrete architecturale verandering die het ecosysteem zelfversterkend maakt. Meer plugins → meer gebruikers → meer ontwikkelaars → meer plugins. Als die cyclus eenmaal draait, is hij moeilijk te stoppen.
De kreeft heeft een nieuwe schaar gekregen.