OpenClaw Active Memory: KI-Gedächtnis in 5 Minuten

In deinen Agent kopieren

Kopiere das hier in deinen Agent, wenn du Active Memory mit einem in sich geschlossenen Setup und sicheren Standardwerten aktivieren willst:

{
  plugins: {
    entries: {
      "active-memory": {
        enabled: true,
        config: {
          enabled: true,
          agents: ["main"],
          allowedChatTypes: ["direct"],
          modelFallbackPolicy: "default-remote",
          queryMode: "recent",
          promptStyle: "balanced",
          timeoutMs: 15000,
          maxSummaryChars: 220,
          persistTranscripts: false,
          logging: true,
        },
      },
    },
  },
}

Das schaltet das Plugin für den main Agent ein und beschränkt es standardmäßig auf Direct-Message-Sessions. Es lässt den Agent zuerst das aktuelle Session-Model übernehmen, nutzt aber den eingebauten Remote-Fallback, falls kein explizites oder übernommenes Model verfügbar ist.

Danach startest du das Gateway neu:

openclaw gateway

Um es live in einer Konversation zu prüfen:

/verbose on

Active Memory einschalten

Das sicherste Setup folgt diesem Plan:

Aktiviere das Plugin.
Wähle einen Conversational Agent aus.
Lass das Logging nur während des Tunings an.
Starte das Gateway neu, um die Änderungen zu übernehmen.

Starte mit diesem Eintrag in der openclaw.json:

{
  plugins: {
    entries: {
      "active-memory": {
        enabled: true,
        config: {
          agents: ["main"],
          allowedChatTypes: ["direct"],
          modelFallbackPolicy: "default-remote",
          queryMode: "recent",
          promptStyle: "balanced",
          timeoutMs: 15000,
          maxSummaryChars: 220,
          persistTranscripts: false,
          logging: true,
        },
      },
    },
  },
}

Dann starte das Gateway neu:

openclaw gateway

Das bedeuten die Einstellungen:

plugins.entries.active-memory.enabled: true schaltet das Plugin ein.
config.agents: ["main"] aktiviert Active Memory nur für den main Agent.
config.allowedChatTypes: ["direct"] sorgt dafür, dass Active Memory standardmäßig nur für Direct-Message-Sessions aktiv bleibt.
Wenn config.model nicht gesetzt ist, übernimmt Active Memory zuerst das Model der aktuellen Session.
config.modelFallbackPolicy: "default-remote" behält den eingebauten Remote-Fallback als Standard bei, wenn kein explizites oder übernommenes Model verfügbar ist.
config.promptStyle: "balanced" nutzt den standardmäßigen Allzweck-Prompt-Stil für den recent Modus.
Active Memory läuft weiterhin nur bei berechtigten interaktiven, persistenten Chat-Sessions.

So siehst du es in Aktion

Active Memory fügt versteckten System-Context für das Model hinzu. Es zeigt dem Client keine rohen <active_memory_plugin>...</active_memory_plugin> Tags an.

Session-Umschalter

Nutze den Plugin-Befehl, wenn du Active Memory für die aktuelle Chat-Session pausieren oder fortsetzen willst, ohne die Config zu bearbeiten:

/active-memory status
/active-memory off
/active-memory on

Das gilt nur für die jeweilige Session. Es ändert weder plugins.entries.active-memory.enabled, das Agent-Targeting noch andere globale Konfigurationen.

Wenn der Befehl die Config schreiben und Active Memory für alle Sessions pausieren oder fortsetzen soll, nutze die explizite globale Form:

/active-memory status --global
/active-memory off --global
/active-memory on --global

Die globale Form schreibt in plugins.entries.active-memory.config.enabled. Sie lässt plugins.entries.active-memory.enabled auf “true”, damit der Befehl verfügbar bleibt, um Active Memory später wieder einzuschalten.

Wenn du sehen willst, was Active Memory in einer Live-Session macht, schalte den Verbose-Modus für diese Session ein:

/verbose on

Mit aktiviertem Verbose-Modus kann OpenClaw Folgendes anzeigen:

Eine Active Memory Statuszeile wie Active Memory: ok 842ms recent 34 chars.
Eine lesbare Debug-Zusammenfassung wie Active Memory Debug: Lemon pepper wings with blue cheese..

Diese Zeilen stammen aus demselben Active Memory Durchlauf, der den versteckten System-Context füttert. Sie sind jedoch für Menschen formatiert, anstatt rohes Prompt-Markup anzuzeigen.

Standardmäßig ist das Transkript des blockierenden Memory Sub-Agents temporär und wird nach Abschluss des Durchlaufs gelöscht.

Beispiel-Ablauf:

/verbose on
what wings should i order?

Erwartete Form der Antwort:

...normal assistant reply...

🧩 Active Memory: ok 842ms recent 34 chars
🔎 Active Memory Debug: Lemon pepper wings with blue cheese.

Wann es läuft

Active Memory nutzt zwei Gates:

Config opt-in Das Plugin muss aktiviert sein und die aktuelle Agent-ID muss in plugins.entries.active-memory.config.agents hinterlegt sein.
Strikte Runtime-Berechtigung Selbst wenn das Feature aktiviert und konfiguriert ist, läuft Active Memory nur für berechtigte interaktive, persistente Chat-Sessions.

Die eigentliche Regel lautet:

plugin enabled
+
agent id targeted
+
allowed chat type
+
eligible interactive persistent chat session
=
active memory runs

Wenn eine dieser Bedingungen nicht erfüllt ist, wird Active Memory nicht ausgeführt.

Session-Typen

Über config.allowedChatTypes steuerst du, welche Arten von Konversationen Active Memory überhaupt nutzen dürfen.

Der Standardwert ist:

allowedChatTypes: ["direct"]

Das bedeutet, dass Active Memory standardmäßig in Sessions im Direct-Message-Stil läuft. In Gruppen- oder Channel-Sessions ist es deaktiviert, außer du aktivierst sie explizit.

Beispiele:

allowedChatTypes: ["direct"]

allowedChatTypes: ["direct", "group"]

allowedChatTypes: ["direct", "group", "channel"]

Wo es läuft

Active Memory ist ein Feature zur Anreicherung von Konversationen und kein plattformweites Inference-Feature.

Oberfläche	Läuft Active Memory?
Control UI / Web-Chat persistente Sessions	Ja, wenn das Plugin aktiviert und der Agent ausgewählt ist
Andere interaktive Channel-Sessions auf demselben persistenten Pfad	Ja, wenn das Plugin aktiviert und der Agent ausgewählt ist
Headless One-Shot-Runs	Nein
Heartbeat/Hintergrund-Runs	Nein
Generische interne `agent-command`-Pfade	Nein
Sub-Agent/interne Helper-Ausführung	Nein

Warum du es nutzen solltest

Setze Active Memory in diesen Fällen ein:

Die Session ist persistent sowie benutzerorientiert und der Agent verfügt über ein sinnvolles Langzeitgedächtnis.
Kontinuität und Personalisierung sind dir wichtiger als reine Prompt-Determiniertheit.

Es eignet sich besonders gut für:

Stabile Präferenzen und wiederkehrende Gewohnheiten.
Langfristigen User-Kontext, der sich ganz natürlich in das Gespräch einfügen soll.

In diesen Szenarien ist es eher ungeeignet:

Automatisierung
Interne Worker
One-Shot-API-Tasks
Umgebungen, in denen eine versteckte Personalisierung die Nutzer überraschen würde

Wie es funktioniert

So sieht der Ablauf zur Laufzeit aus:

flowchart LR
  U["User Message"] --> Q["Build Memory Query"]
  Q --> R["Active Memory Blocking Memory Sub-Agent"]
  R -->|NONE or empty| M["Main Reply"]
  R -->|relevant summary| I["Append Hidden active_memory_plugin System Context"]
  I --> M["Main Reply"]

Der blockierende Memory Sub-Agent kann ausschließlich diese Tools nutzen:

memory_search
memory_get

Falls die Verbindung schwach ist, gibt er NONE zurück. Das stellt sicher, dass der Prozess nicht unnötig hängen bleibt.

Query-Modi

Über config.queryMode steuerst du, wie viel von der aktuellen Konversation der blockierende Memory Sub-Agent zu sehen bekommt.

Prompt-Styles

config.promptStyle legt fest, wie offensiv oder streng der Memory Sub-Agent entscheidet, ob er Daten aus dem Speicher zurückgibt.

Diese Styles stehen dir zur Verfügung:

balanced: Der Standard-Allrounder für den recent Modus.
strict: Sehr zurückhaltend; die beste Wahl, wenn du kaum Einflüsse aus dem direkten Kontext wünschst.
contextual: Fokus auf Kontinuität; ideal, wenn der Gesprächsverlauf eine größere Rolle spielen soll.
recall-heavy: Sucht großzügiger nach Treffern, auch bei weniger exakten Übereinstimmungen.
precision-heavy: Bevorzugt aggressiv NONE, außer ein Treffer ist absolut eindeutig.
preference-only: Optimiert für Favoriten, Gewohnheiten, Routinen und wiederkehrende persönliche Fakten.

Standard-Mapping, wenn config.promptStyle nicht definiert ist:

message -> strict
recent -> balanced
full -> contextual

Sobald du config.promptStyle explizit konfigurierst, wird diese Standard-Logik überschrieben.

Beispiel:

promptStyle: "preference-only"

Model-Fallback-Strategie

Wenn config.model nicht gesetzt ist, versucht Active Memory ein Model in dieser Reihenfolge aufzulösen:

explicit plugin model
-> current session model
-> agent primary model
-> optional built-in remote fallback

config.modelFallbackPolicy steuert dabei den letzten Schritt dieser Kette.

Standardwert:

modelFallbackPolicy: "default-remote"

Andere Option:

modelFallbackPolicy: "resolved-only"

Nutze am besten resolved-only, wenn Active Memory den Abruf lieber überspringen soll, anstatt auf das integrierte Remote-Default zurückzugreifen, falls kein explizites oder vererbtes Model verfügbar ist.

Fortgeschrittene Escape Hatches

Diese Optionen gehören absichtlich nicht zum empfohlenen Setup.

config.thinking kann das Thinking-Level des blockierenden Memory Sub-Agent überschreiben:

thinking: "medium"

Standard:

thinking: "off"

Aktiviere das nicht standardmäßig. Active Memory läuft im Reply-Pfad, daher erhöht zusätzliche Thinking-Zeit direkt die für Nutzer sichtbare Latenz.

config.promptAppend fügt zusätzliche Operator-Anweisungen nach dem Standard-Prompt von Active Memory und vor dem Konversationskontext hinzu:

promptAppend: "Prefer stable long-term preferences over one-off events."

config.promptOverride ersetzt den Standard-Prompt von Active Memory komplett. OpenClaw hängt danach trotzdem den Konversationskontext an:

promptOverride: "You are a memory search agent. Return NONE or one compact user fact."

Prompt-Anpassungen sind nicht empfehlenswert, außer du testest bewusst einen anderen Recall-Contract. Der Standard-Prompt ist darauf optimiert, entweder NONE oder kompakten Kontext zu Nutzerfakten für das Main Model zurückzugeben.

`message`

Nur die letzte Nachricht des Nutzers wird gesendet.

Latest user message only

Nutze das, wenn:

du das schnellste Verhalten sowie die stärkste Gewichtung auf den Recall stabiler Präferenzen willst
Follow-up-Turns keinen Konversationskontext benötigen

Empfohlener Timeout:

starte bei etwa 3000 bis 5000 ms

`recent`

Die letzte Nachricht des Nutzers plus ein kleiner Teil des aktuellen Konversationsverlaufs wird gesendet.

Recent conversation tail:
user: ...
assistant: ...
user: ...

Latest user message:
...

Nutze das, wenn:

du eine gute Balance zwischen Geschwindigkeit und kontextuellem Grounding willst
Follow-up-Fragen oft von den letzten paar Turns abhängen

Empfohlener Timeout:

starte bei etwa 15000 ms

`full`

Die gesamte Konversation wird an den blockierenden Memory Sub-Agent gesendet.

Full conversation context:
user: ...
assistant: ...
user: ...
...

Nutze das, wenn:

die Qualität des Recalls wichtiger ist als die Latenz
die Konversation wichtiges Setup weit oben im Thread enthält

Empfohlener Timeout:

erhöhe ihn deutlich im Vergleich zu message oder recent
starte bei etwa 15000 ms oder höher, abhängig von der Thread-Größe

Generell gilt, dass der Timeout mit der Kontextgröße steigen sollte:

message < recent < full

Transkript-Persistenz

Die Durchläufe des blockierenden Memory Sub-Agent von Active Memory erstellen während des Aufrufs ein echtes session.jsonl Transkript.

Standardmäßig ist dieses Transkript temporär:

es wird in ein Temp-Verzeichnis geschrieben
es wird nur für den Durchlauf des Memory Sub-Agent genutzt und sofort nach Abschluss gelöscht

Wenn du diese Transkripts zur Fehlersuche oder Inspektion auf der Festplatte behalten willst, aktiviere die Persistenz explizit:

{
  plugins: {
    entries: {
      "active-memory": {
        enabled: true,
        config: {
          agents: ["main"],
          persistTranscripts: true,
          transcriptDir: "active-memory",
        },
      },
    },
  },
}

Wenn aktiviert, speichert Active Memory die Transkripts in einem separaten Verzeichnis unter dem Sessions-Ordner des Ziel-Agents, nicht im Hauptpfad der Nutzerkonversation.

Das Standard-Layout sieht konzeptionell so aus:

agents/<agent>/sessions/active-memory/<blocking-memory-sub-agent-session-id>.jsonl

Du kannst das relative Unterverzeichnis mit config.transcriptDir ändern.

Nutze das vorsichtig:

Transkripts des Memory Sub-Agent können sich bei aktiven Sessions schnell anhäufen und der full Query-Modus dupliziert dabei viel Konversationskontext
diese Transkripts enthalten versteckten Prompt-Kontext und abgerufene Memories

Konfiguration

Die gesamte Konfiguration für active-memory findest du unter:

plugins.entries.active-memory

Das sind die wichtigsten Felder:

Key	Type	Bedeutung
`enabled`	`boolean`	Aktiviert das Plugin
`config.agents`	`string[]`	Agent-IDs, die active-memory nutzen dürfen
`config.model`	`string`	Optionale Modell-Referenz für den blockierenden Memory-Sub-Agent; falls nicht gesetzt, nutzt active-memory das aktuelle Session-Modell
`config.queryMode`	`"message" \| "recent" \| "full"`	Steuert, wie viel von der Konversation der blockierende Memory-Sub-Agent sieht
`config.promptStyle`	`"balanced" \| "strict" \| "contextual" \| "recall-heavy" \| "precision-heavy" \| "preference-only"`	Steuert, wie offensiv oder strikt der blockierende Memory-Sub-Agent entscheidet, ob Memory zurückgegeben wird
`config.thinking`	`"off" \| "minimal" \| "low" \| "medium" \| "high" \| "xhigh" \| "adaptive"`	Fortgeschrittener Thinking-Override für den blockierenden Memory-Sub-Agent; Standard ist `off` für mehr Speed
`config.promptOverride`	`string`	Kompletter Prompt-Ersatz; für den normalen Gebrauch nicht empfohlen
`config.promptAppend`	`string`	Zusätzliche Anweisungen, die an den Standard- oder Overridden-Prompt angehängt werden
`config.timeoutMs`	`number`	Hard-Timeout für den blockierenden Memory-Sub-Agent
`config.maxSummaryChars`	`number`	Maximal erlaubte Zeichenanzahl in der active-memory Zusammenfassung
`config.logging`	`boolean`	Gibt active-memory Logs während des Tunings aus
`config.persistTranscripts`	`boolean`	Speichert Transcripts des blockierenden Memory-Sub-Agents auf der Festplatte, statt temporäre Dateien zu löschen
`config.transcriptDir`	`string`	Relatives Verzeichnis für Transcripts des blockierenden Memory-Sub-Agents unter dem Agent-Sessions-Ordner

Nützliche Felder für das Tuning:

Key	Type	Bedeutung
`config.maxSummaryChars`	`number`	Maximal erlaubte Zeichenanzahl in der active-memory Zusammenfassung
`config.recentUserTurns`	`number`	Vorherige User-Turns, die einbezogen werden, wenn `queryMode` auf `recent` steht
`config.recentAssistantTurns`	`number`	Vorherige Assistant-Turns, die einbezogen werden, wenn `queryMode` auf `recent` steht
`config.recentUserChars`	`number`	Maximale Zeichen pro User-Turn
`config.recentAssistantChars`	`number`	Maximale Zeichen pro Assistant-Turn
`config.cacheTtlMs`	`number`	Cache-Wiederverwendung für identische Queries

Empfohlenes Setup

Fang am besten mit recent an.

{
  plugins: {
    entries: {
      "active-memory": {
        enabled: true,
        config: {
          agents: ["main"],
          queryMode: "recent",
          promptStyle: "balanced",
          timeoutMs: 15000,
          maxSummaryChars: 220,
          logging: true,
        },
      },
    },
  },
}

Wenn du das Verhalten während des Tunings live prüfen willst, nutze /verbose on in der Session, anstatt nach einem eigenen Debug-Befehl für active-memory zu suchen.

Danach kannst du wechseln zu:

message, wenn du eine niedrigere Latency willst
full, wenn du entscheidest, dass zusätzlicher Kontext den langsameren blockierenden Memory-Sub-Agent wert ist

Fehlerbehebung

Falls Active Memory nicht dort auftaucht, wo du es erwartest:

Bestätige, dass das Plugin unter plugins.entries.active-memory.enabled aktiviert ist.
Überprüfe, ob die aktuelle Agent ID in config.agents gelistet ist.
Stell sicher, dass du innerhalb einer interaktiven, persistenten Chat-Session testest.
Aktiviere config.logging: true und behalte die Gateway-Logs im Auge.
Verifiziere mit openclaw memory status --deep, ob die Memory-Suche an sich funktioniert.

Wenn die Memory-Treffer zu ungenau sind, solltest du diesen Wert einschränken:

maxSummaryChars

Wenn Active Memory zu langsam ist:

queryMode verringern
timeoutMs senken
Anzahl der letzten Turns reduzieren
Zeichenbegrenzung pro Turn (char caps) reduzieren

Noch festgefahren?

Wenn diese Seite nicht hilft, frage OpenClaw Expert nach Schritt-fuer-Schritt-Loesungen.

OpenClaw Active Memory: KI-Gedächtnis in 5 Minuten

In deinen Agent kopieren

Active Memory einschalten

So siehst du es in Aktion

Session-Umschalter

Wann es läuft

Session-Typen

Wo es läuft

Warum du es nutzen solltest

Wie es funktioniert

Query-Modi

Prompt-Styles

Model-Fallback-Strategie

Fortgeschrittene Escape Hatches

message

recent

full

Transkript-Persistenz

Konfiguration

Empfohlenes Setup

Fehlerbehebung

Verwandte Seiten

Noch festgefahren?

`message`

`recent`

`full`