Contextengine

Een context-engine bepaalt hoe OpenClaw modelcontext opbouwt voor elke uitvoering: welke berichten worden opgenomen, hoe oudere geschiedenis wordt samengevat en hoe context over subagent-grenzen heen wordt beheerd.

OpenClaw wordt geleverd met een ingebouwde legacy-engine en gebruikt die standaard - de meeste gebruikers hoeven dit nooit te wijzigen. Installeer en selecteer alleen een Plugin-engine wanneer je ander assemblage-, compaction- of cross-session recall-gedrag wilt.

# Snel aan de slag

openclaw doctor
# or inspect config directly:
cat ~/.openclaw/openclaw.json | jq '.plugins.slots.contextEngine'

openclaw plugins install @martian-engineering/lossless-claw

openclaw plugins install -l ./my-context-engine

// openclaw.json
{
  plugins: {
    slots: {
      contextEngine: "lossless-claw", // must match the plugin's registered engine id
    },
    entries: {
      "lossless-claw": {
        enabled: true,
        // Plugin-specific config goes here (see the plugin's docs)
      },
    },
  },
}

# Hoe het werkt

Telkens wanneer OpenClaw een modelprompt uitvoert, neemt de context-engine deel op vier lifecycle-punten:

Voor de gebundelde niet-ACP Codex-harness past OpenClaw dezelfde lifecycle toe door geassembleerde context te projecteren naar Codex-ontwikkelaarsinstructies en de prompt van de huidige beurt. Codex blijft eigenaar van zijn native threadgeschiedenis en native compactor.

# Subagent-lifecycle (optioneel)

OpenClaw roept twee optionele subagent-lifecyclehooks aan:

# Systeemprompttoevoeging

De methode assemble kan een systemPromptAddition-string retourneren. OpenClaw voegt deze vooraan toe aan de systeemprompt voor de uitvoering. Hierdoor kunnen engines dynamische recall-begeleiding, retrieval-instructies of contextbewuste hints injecteren zonder statische workspace-bestanden te vereisen.

# De legacy-engine

De ingebouwde legacy-engine behoudt het oorspronkelijke gedrag van OpenClaw:

• Ingest: no-op (de sessiemanager handelt berichtpersistentie rechtstreeks af).
• Assemble: pass-through (de bestaande sanitize -> validate -> limit-pipeline in de runtime handelt contextassemblage af).
• Compact: delegeert naar de ingebouwde summarization compaction, die een enkele samenvatting van oudere berichten maakt en recente berichten intact houdt.
• After turn: no-op.

De legacy-engine registreert geen tools en levert geen systemPromptAddition.

Wanneer er geen plugins.slots.contextEngine is ingesteld (of deze is ingesteld op "legacy"), wordt deze engine automatisch gebruikt.

# Plugin-engines

Een Plugin kan een context-engine registreren met de plugin-API:

export default function register(api) {
  api.registerContextEngine("my-engine", (ctx) => ({
    info: {
      id: "my-engine",
      name: "My Context Engine",
      ownsCompaction: true,
    },

    async ingest({ sessionId, message, isHeartbeat }) {
      // Store the message in your data store
      return { ingested: true };
    },

    async assemble({ sessionId, messages, tokenBudget, availableTools, citationsMode }) {
      // Return messages that fit the budget
      return {
        messages: buildContext(messages, tokenBudget),
        estimatedTokens: countTokens(messages),
        systemPromptAddition: buildMemorySystemPromptAddition({
          availableTools: availableTools ?? new Set(),
          citationsMode,
        }),
      };
    },

    async compact({ sessionId, force }) {
      // Summarize older context
      return { ok: true, compacted: true };
    },
  }));
}

De factory ctx bevat optionele waarden voor config, agentDir en workspaceDir, zodat plugins per-agent- of per-workspace-status kunnen initialiseren voordat de eerste lifecycle-hook wordt uitgevoerd.

Schakel die vervolgens in de configuratie in:

{
  plugins: {
    slots: {
      contextEngine: "my-engine",
    },
    entries: {
      "my-engine": {
        enabled: true,
      },
    },
  },
}

# De ContextEngine-interface

Vereiste leden:

assemble retourneert een AssembleResult met:

compact retourneert een CompactResult. Wanneer compaction het actieve transcript roteert, identificeren result.sessionId en result.sessionFile de opvolgende sessie die de volgende retry of beurt moet gebruiken.

Optionele leden:

# ownsCompaction

ownsCompaction bepaalt of Pi's ingebouwde auto-compaction binnen de poging ingeschakeld blijft voor de uitvoering:

Dat betekent dat er twee geldige Plugin-patronen zijn:

Een no-op compact() is onveilig voor een actieve niet-eigenaar-engine, omdat deze het normale /compact- en overflow-recovery-compaction-pad voor die engineslot uitschakelt.

# Configuratiereferentie

{
  plugins: {
    slots: {
      // Select the active context engine. Default: "legacy".
      // Set to a plugin id to use a plugin engine.
      contextEngine: "legacy",
    },
  },
}

# Relatie tot compaction en geheugen

# Tips

• Gebruik openclaw doctor om te controleren of je engine correct wordt geladen.
• Als je van engine wisselt, gaan bestaande sessies door met hun huidige geschiedenis. De nieuwe engine neemt toekomstige runs over.
• Enginefouten worden gelogd en weergegeven in diagnostics. Als een plugin-engine niet kan worden geregistreerd of de geselecteerde engine-id niet kan worden opgelost, valt OpenClaw niet automatisch terug; runs mislukken totdat je de plugin repareert of plugins.slots.contextEngine terugzet naar "legacy".
• Gebruik voor ontwikkeling openclaw plugins install -l ./my-engine om een lokale pluginmap te koppelen zonder te kopiëren.

# Gerelateerd

• Compaction - lange gesprekken samenvatten
• Context - hoe context wordt opgebouwd voor agentbeurten
• Plugin-architectuur - context-engineplugins registreren
• Pluginmanifest - velden van het pluginmanifest
• Plugins - pluginoverzicht