Bienvenue sur FlowZap, l'application pour créer des diagrammes avec Rapidité, Clarté et Contrôle.

Votre agent IA est intelligent. Il souffre quand même d’amnésie.

07/03/2026

Tags: agents ia, mémoire agentique, architecture mémoire, rag, openclaw, systèmes multi-agents

Jules Kovac

Jules Kovac

Business Analyst, Founder

Votre agent IA est intelligent. Il souffre quand même d’amnésie.

La plupart des agents IA n’échouent pas parce que le modèle est bête ; ils échouent parce que le système oublie ce qui compte. Une fenêtre de contexte n’est qu’une mémoire de travail à court terme. Fermez l’onglet, changez de canal ou atteignez la limite de tokens, et votre « mémoire » disparaît.

Si vous bricolez avec OpenClaw, ZeroClaw, NanoClaw, ou votre propre runtime de type claw, cet article parle de la couche la plus banale mais aussi la plus critique : comment votre agent se souvient réellement.

Ici, « mémoire » désigne des structures système qui stockent et récupèrent des informations à travers les tours, les tâches et les sessions — pas juste « j’ai monté la fenêtre de contexte à 16k ».

Les 7 patterns ci-dessous couvrent les besoins les plus fréquents :

  • Mémoire de session – l’état de travail à court terme.
  • Résumé glissant – l’historique compressé.
  • Mémoire de profil – l’identité et les préférences stables.
  • Mémoire sémantique – memorySearch, knowledge vault, RAG.
  • Mémoire épisodique – runs, journaux d’événements, épisodes.
  • Récupération hybride – mélange vectoriel, mots-clés et récence.
  • Mémoire partagée – une couche d’état commune à plusieurs agents ou canaux.

 

 

Pattern 1 – Mémoire de session

La mémoire de session est le tableau blanc de la conversation en cours : l’historique actif que l’agent transporte d’un message à l’autre. Dans OpenClaw, cela correspond directement au buffer d’historique de conversation.

 

Comment ça fonctionne

  • Le canal envoie le nouveau message avec l’historique récent.
  • Le runtime fusionne cet historique avec l’état local de la session.
  • Le prompt est assemblé puis envoyé au LLM.
  • La réponse est ensuite réinjectée dans le même historique.

 

Impact performance / UX

  • Performance : peu coûteux au départ, mais le coût et la latence montent avec la longueur de l’historique.
  • UX : la continuité à court terme est excellente, jusqu’au moment où l’historique est tronqué silencieusement.

 

Correspondance OpenClaw

  • Natif : oui.
  • Où : dans les logs de conversation et l’état de session en mémoire.

 

FlowZap Code – Mémoire de session

User { # User
n1: circle label:"User sends message"
n2: rectangle label:"See agent reply"

n1.handle(right) -> Agent.n3.handle(left)
Agent.n8.handle(right) -> n2.handle(left)
}

Agent { # Agent
n3: rectangle label:"Receive message"
n4: rectangle label:"Load session history"
n5: rectangle label:"Assemble prompt"
n6: rectangle label:"Call LLM"
n7: rectangle label:"Receive LLM reply"
n8: rectangle label:"Return answer to user"
n9: rectangle label:"Persist updated session"

n3.handle(right) -> n4.handle(left)
n4.handle(right) -> n5.handle(left)
n5.handle(right) -> n6.handle(left)
n6.handle(right) -> LLM.n10.handle(left)
n7.handle(right) -> n8.handle(left)
n8.handle(bottom) -> n9.handle(top) [label="Save session"]
}

Memory { # Session Store
n11: rectangle label:"Read session state"
n12: rectangle label:"Write session state"

n3.handle(bottom) -> n11.handle(top) [label="Get history"]
n11.handle(right) -> Agent.n4.handle(left)
Agent.n9.handle(bottom) -> n12.handle(top) [label="Store history"]
}

LLM { # LLM
n10: rectangle label:"Generate answer"

n10.handle(right) -> Agent.n7.handle(left)
}

 

 

Pattern 2 – Résumé glissant

Le résumé glissant est le pattern « notes de réunion » : au lieu d’envoyer toute la transcription, vous résumez périodiquement les derniers échanges dans un état compact que vous conservez.

 

Comment ça fonctionne

  • Vous gardez l’historique complet pendant un temps.
  • À un certain seuil, vous résumez le dernier segment.
  • Vous remplacez les détails par un résumé plus court dans le prompt.

 

Impact performance / UX

  • Performance : réduit fortement la taille des prompts dans les longues conversations.
  • UX : l’agent conserve l’essentiel sans rupture brutale, mais perd du détail fin.

 

Correspondance OpenClaw

  • Natif : partiellement.
  • Où : via Memory Flush, MEMORY.md, memory/ et vos mécanismes de compression.

 

FlowZap Code – Résumé glissant

User { # User
n1: circle label:"New message"
n2: rectangle label:"See reply"

n1.handle(right) -> Agent.n3.handle(left)
Agent.n12.handle(right) -> n2.handle(left)
}

Agent { # Agent
n3: rectangle label:"Append turn to history"
n4: diamond label:"Summary threshold reached?"
n5: rectangle label:"Request latest summary"
n6: rectangle label:"Build compact prompt"
n7: rectangle label:"Call LLM"
n12: rectangle label:"Return answer"

n3.handle(right) -> n4.handle(left)
n4.handle(right) -> Summarizer.n8.handle(left) [label="Yes"]
n4.handle(bottom) -> n5.handle(top) [label="No"]
n5.handle(bottom) -> SummaryStore.n10.handle(top) [label="Load summary"]
n6.handle(right) -> n7.handle(left)
n7.handle(right) -> LLM.n13.handle(left)
}

 

 

Pattern 3 – Mémoire de profil

La mémoire de profil correspond à la couche « voilà qui je suis » : les faits stables sur l’utilisateur et l’agent, comme le nom, le fuseau horaire, les outils, les préférences et les contraintes.

 

Comment ça fonctionne

  • Le runtime charge les données de profil au début de la session.
  • Chaque prompt combine persona système, profil utilisateur et message courant.
  • Les nouveaux faits importants peuvent être réécrits dans la mémoire de profil.

 

Impact performance / UX

  • Performance : surcharge faible et prévisible.
  • UX : gros gain de personnalisation perçue.

 

Correspondance OpenClaw

  • Natif : oui.
  • Où : SOUL.md, USER.md, MEMORY.md et autres fichiers mémoire Markdown.

 

 

Pattern 4 – Mémoire sémantique

La mémoire sémantique est votre base de connaissances long terme : faits, notes, documents et conversations vectorisés puis récupérés par similarité.

 

Comment ça fonctionne

  • Le texte est découpé, vectorisé puis stocké dans une base vectorielle.
  • Lors d’une requête, vous vectorisez la question, lancez la recherche, rerankez, puis injectez les meilleurs résultats dans le prompt.

 

Impact performance / UX

  • Performance : coût IO supplémentaire et davantage de tokens injectés.
  • UX : c’est souvent là que l’agent semble « tout retenir » sans halluciner autant.

 

Correspondance OpenClaw

  • Natif : oui, via memorySearch ou des skills similaires.
  • Où : SQLite+vec ou un backend vectoriel externe.

 

 

Pattern 5 – Mémoire épisodique

La mémoire épisodique est le journal d’expérience de l’agent : chaque épisode correspond à une exécution passée avec son contexte, son plan, ses outils et son résultat.

 

Comment ça fonctionne

  • Chaque run devient un épisode structuré.
  • Avant une nouvelle tâche, l’agent recherche des épisodes similaires et s’en inspire.

 

Impact performance / UX

  • Performance : stockage et indexation supplémentaires.
  • UX : l’agent donne l’impression d’apprendre de l’expérience passée.

 

Correspondance OpenClaw

  • Natif : les signaux bruts existent déjà.
  • Où : logs, spans, métriques et historiques de run.

 

 

Pattern 6 – Récupération hybride

La récupération hybride est le pattern « arrêtez d’opposer les approches, utilisez les trois » : mélangez recherche vectorielle, recherche par mot-clé ou identifiant, et recherche par récence avant de construire le contexte final.

En pratique, c’est souvent le pattern le plus robuste en production, parce que chaque méthode couvre un angle mort différent.

Ouvrir le schéma de récupération hybride

 

Comment ça fonctionne

  • Le planificateur choisit les modes de récupération pertinents.
  • La recherche sémantique, exacte et récente s’exécute en parallèle.
  • Les résultats sont fusionnés puis rerankés dans un ensemble de contexte unique.

 

Impact performance / UX

  • Performance : davantage d’appels, donc davantage de latence si vous ne limitez pas bien.
  • UX : meilleur rappel global, y compris pour les références floues et les identifiants exacts.

 

Correspondance OpenClaw

  • Natif : oui, conceptuellement.
  • Où : dans votre couche de routage, vos middlewares ou votre graphe de skills.

 

FlowZap Code – Récupération hybride

User { # User
n1: circle label:"Ask mixed query"
n2: rectangle label:"See answer"

n1.handle(right) -> Agent.n3.handle(left)
Agent.n18.handle(right) -> n2.handle(left)
}

Agent { # Agent
n3: rectangle label:"Plan retrieval strategy"
n4: rectangle label:"Trigger semantic search"
n5: rectangle label:"Trigger keyword search"
n6: rectangle label:"Trigger recent-history search"
n7: rectangle label:"Merge and rerank"
n8: rectangle label:"Build prompt with hybrid context"
n9: rectangle label:"Call LLM"
n18: rectangle label:"Return answer"

n3.handle(bottom) -> n4.handle(top) [label="Semantic"]
n3.handle(right) -> n5.handle(left) [label="Keyword"]
n3.handle(left) -> n6.handle(right) [label="Recent"]
n7.handle(right) -> n8.handle(left)
n8.handle(right) -> n9.handle(left)
n9.handle(right) -> LLM.n19.handle(left)
}

 

 

Pattern 7 – Mémoire partagée

La mémoire partagée est le cerveau central des systèmes multi-agents ou multi-canaux : plusieurs agents lisent et écrivent dans la même couche d’état au lieu de transporter d’énormes prompts séparés.

 

Comment ça fonctionne

  • L’orchestrateur découpe le travail en sous-tâches.
  • Les agents spécialisés lisent et écrivent dans l’état partagé.
  • L’orchestrateur compose la réponse finale à partir de cet état.

 

Impact performance / UX

  • Performance : moins de gros prompts, plus de petites lectures/écritures.
  • UX : les systèmes multi-agents paraissent cohérents au lieu d’être fragmentés.

 

Correspondance OpenClaw

  • Natif : oui, en grande partie.
  • Où : dans l’arbre mémoire partagé entre canaux, sessions et éventuellement agents auxiliaires.

 

 

Comment cela s’intègre à OpenClaw

Si vous utilisez OpenClaw aujourd’hui, vous disposez déjà d’une bonne partie de ces patterns :

  • Mémoire de session – historique de conversation et état courant.
  • Résumé glissant – compression avant troncature du contexte.
  • Mémoire de profil – SOUL.md, USER.md, MEMORY.md.
  • Mémoire sémantique – memorySearch, knowledge-vault, backend vectoriel.
  • Mémoire épisodique – logs, spans et historiques de run.
  • Récupération hybride – combinaison de recherche sémantique, fichiers bruts et récence.
  • Mémoire partagée – arbre mémoire commun à plusieurs canaux et agents.

Le vrai enjeu n’est donc pas d’ajouter encore une base de données, mais de nommer le pattern mémoire utilisé à chaque endroit et de le visualiser clairement.

 

 

Inspirations:

Retour à tous les articles du blogue