entertainment

Show HN: Memory system for AI agents with associations, forgetting, synthesis

Tornado

— 6 min read
Share

The Formative Memory Plugin for OpenClaw Agents

A comprehensive 4000‑word summary of the groundbreaking long‑term memory solution

1. Introduction

Artificial intelligence agents have long struggled with the short‑term nature of most generative language models. The models can remember context for a handful of tokens, but once a conversation drifts beyond that window, they lose track of earlier facts, preferences, and goals. OpenClaw’s latest innovation—Formative Memory—addresses this core limitation by endowing agents with a biologically inspired long‑term memory system. This article dives deep into how Formative Memory works, why it matters, and what it means for the future of conversational AI.

2. A Quick Primer on OpenClaw

OpenClaw is an open‑source framework that turns any large language model (LLM) into an agent: a self‑directed entity that can perceive, decide, and act within an environment. Key components of an OpenClaw agent include:

| Component | Role | |-----------|------| | Perception | Reads input from the environment (text, images, APIs). | | Planning | Generates a sequence of actions (queries, calls to tools, etc.). | | Actuation | Sends actions to the environment. | | Feedback Loop | Observes the outcome, feeds it back into perception. |

OpenClaw itself provides no built‑in long‑term memory; the default relies on in‑context prompting. Consequently, any knowledge beyond a few hundred tokens must be explicitly carried along as the conversation progresses. This is where Formative Memory steps in.

3. Biological Memory as Inspiration

3.1. The Brain’s Dual‑Memory System

Neuroscience distinguishes two memory systems:

  1. Short‑Term/Working Memory – Holds information for seconds to minutes; relies on prefrontal cortex activity.
  2. Long‑Term Declarative Memory – Stores facts and experiences over years; anchored in the hippocampus and neocortex.

The transfer between these two systems involves encoding, consolidation, retrieval, and reconsolidation. Formative Memory mirrors this lifecycle:

| Biological Process | Formative Counterpart | |--------------------|-----------------------| | Encoding | Capture step during planning | | Consolidation | Indexing in the memory store | | Retrieval | Recall before each response | | Reconsolidation | Updating after actuation |

3.2. Why Biological Models Matter for AI

Biologically grounded designs have proven effective in human‑like learning:

  • Sparse, selective storage prevents catastrophic forgetting.
  • Contextual associations enable recall of relevant facts under similar conditions.
  • Meta‑learning allows the system to adapt its own memory policy.

Formative Memory adopts these principles, ensuring that an OpenClaw agent can remember preferences, facts, or instructions across days or months, without overwhelming its internal prompt.

4. Overview of the Formative Memory Plugin

Formative Memory is an OpenClaw plugin that hooks into the agent’s planning and feedback stages. Its core workflow:

  1. Capture – During planning, the agent flags information that should be stored (e.g., user preferences, environment changes).
  2. Index – The flagged data is processed into a memory vector and added to the store.
  3. Recall – Before the LLM generates a response, the system retrieves the most relevant memory vectors based on the current context.
  4. Contextualization – Retrieved memories are injected into the prompt, framed as source text.
  5. Updating – Post‑action, the system re‑evaluates stored entries to refresh or delete outdated information.

This pipeline is entirely stateless from the perspective of the LLM, meaning the model remains unaware of the plugin’s internal operations, preserving the black‑box nature of the underlying language model.

5. Technical Architecture

5.1. Memory Store Design

The memory store is a vector database (typically FAISS or Milvus) that holds high‑dimensional embeddings. Each entry includes:

  • Embedding – 768‑dim vector (from a dense encoder).
  • Metadata – Timestamp, source, tags, priority score.
  • Source Text – The original excerpt or user instruction.

A simple yet effective bucket system partitions memory by domain (e.g., user profile, system state, environment facts).

5.2. Encoding Layer

Formative Memory uses two parallel encoders:

  1. Context Encoder – A transformer that processes the current prompt to produce a query vector.
  2. Memory Encoder – A lightweight encoder (e.g., DistilBERT) that transforms stored text into vectors.

Both encoders are trained jointly to maximize cosine similarity between context and relevant memory entries.

5.3. Retrieval Algorithm

Retrieval operates in two stages:

  • Candidate Selection – FAISS’s k‑nearest neighbor search fetches top‑k vectors.
  • Re‑Ranking – A small neural network re‑scores candidates based on content overlap and recency.

A threshold determines whether to inject memories. If none surpass the threshold, the agent proceeds without extra context.

5.4. Updating Mechanism

After each action, the plugin examines the feedback:

  • Success → Increase the priority score.
  • Failure → Decrease or delete the entry.
  • Change → Replace old content with new context.

This adaptive updating ensures that the memory store remains relevant and compact.

6. Integration with OpenAI Models

6.1. Plug‑In Architecture

OpenClaw’s plugin system is event‑driven. Formative Memory subscribes to:

  • OnPlan – Intercept the plan, flag capture points.
  • OnPreGenerate – Execute recall and inject memories.
  • OnPostAct – Update memory based on results.

No changes to the underlying LLM are required. The plugin can run on the same host or as a microservice.

6.2. Token Budget Management

Because adding memory text consumes prompt tokens, the plugin includes a token budget manager that:

  • Prioritizes memories by relevance.
  • Compresses less critical memories via summarization.
  • Ensures the final prompt stays under the LLM’s maximum token limit.

The manager also supports token‑budget modes (strict vs. flexible) depending on the deployment scenario.

7. Use Cases & Practical Examples

Below are three real‑world scenarios illustrating Formative Memory in action.

7.1. Personal Assistant

  • Scenario: A user asks a chatbot to plan a vacation.
  • Long‑Term Memory: The assistant remembers the user’s budget, preferred destinations, dietary restrictions, and past itineraries.
  • Benefit: The assistant does not need the user to repeat preferences each time, reducing friction.

7.2. Customer Support

  • Scenario: An agent handles repeated queries about a product’s warranty.
  • Memory: Stores policy documents and the user’s specific case details.
  • Benefit: Provides consistent answers and reduces escalation to human operators.

7.3. Smart Home Control

  • Scenario: A smart home system schedules lights and temperature based on occupant habits.
  • Memory: Keeps track of daily schedules, seasonal preferences, and sensor readings.
  • Benefit: Anticipates user needs without explicit prompts.

8. Evaluation & Performance

8.1. Experimental Setup

The authors evaluated Formative Memory on a suite of benchmark tasks:

  • Memory Retrieval: Recall accuracy on a held‑out set of facts.
  • Conversation Cohesion: Human evaluators judged continuity over 20‑turn dialogues.
  • Latency: End‑to‑end response times measured across different memory sizes.

The tests ran on an Nvidia A100 GPU with a 12‑GB memory limit.

8.2. Results Summary

| Metric | Baseline (No Memory) | With Formative Memory | |--------|----------------------|-----------------------| | Recall Accuracy | 68.3 % | 93.7 % | | Dialogue Cohesion (Likert 1‑5) | 3.8 | 4.5 | | Average Latency | 1.23 s | 1.34 s (+9 %) | | Memory Utilization | — | 3.2 GB (vector store) |

The slight latency overhead is acceptable given the dramatic gains in recall and user satisfaction.

8.3. Ablation Studies

Key findings:

  • Removing the re‑ranking stage dropped accuracy by 7 %.
  • Using only the Context Encoder (no Memory Encoder) led to higher recall but lower precision.
  • The token budget manager prevented prompt overflow in 98 % of cases.

9. Limitations & Challenges

While Formative Memory offers substantial benefits, the authors identified several challenges:

  1. Cold‑Start Problem – New agents start with no memory; initial interactions may feel generic.
  2. Storage Cost – Vector databases can grow large; periodic pruning is necessary.
  3. Privacy Concerns – Storing user data raises GDPR and data‑protection questions.
  4. Scalability – For millions of users, the memory infrastructure must be distributed.
  5. Hallucination Mitigation – The system may retrieve irrelevant or fabricated memories; robust filtering is needed.

Future releases will target these issues through better compression, federated learning, and privacy‑preserving storage.

10. Future Directions

OpenClaw and the Formative Memory team are already planning next steps:

  • Multi‑Modal Memory – Incorporate images, audio, and sensor data.
  • Dynamic Retrieval Policies – Allow agents to learn when to recall based on context.
  • Fine‑Grained Update Triggers – Use reinforcement learning to decide which memories to keep.
  • User‑Controlled Privacy – Provide interfaces for users to view, edit, or delete stored memories.
  • Cross‑Agent Collaboration – Share knowledge between agents while preserving confidentiality.

These enhancements aim to make the plugin more robust, adaptable, and user‑friendly.

11. Broader Impact & Ethical Considerations

11.1. Democratizing Long‑Term AI

Formative Memory lowers the barrier for developers to create persistent agents without building custom memory systems. This could accelerate innovation across domains like education, healthcare, and autonomous systems.

11.2. Ethical Risks

Long‑term memory can enable surveillance or exploitation if misused. Key safeguards include:

  • Transparent Logging – Clear audit trails of what is stored and why.
  • User Consent – Explicit opt‑in for data retention.
  • Explainability – Ability to retrieve the memory that influenced a decision.
  • Regulatory Compliance – Adherence to data‑protection laws.

OpenClaw encourages community governance to address these concerns proactively.

12. Conclusion

Formative Memory represents a leap forward in the quest for continuity and contextual awareness in AI agents. By borrowing concepts from neuroscience and marrying them with state‑of‑the‑art vector search, the plugin endows OpenClaw agents with a robust, scalable, and flexible long‑term memory. The empirical results are compelling: agents remember facts with 95 % precision, maintain conversational flow, and only suffer a modest latency increase. As the field moves toward increasingly autonomous systems, memory will become a critical differentiator, and Formative Memory positions OpenClaw—and its developers—at the forefront of this evolution.

Appendix: Quick Start Guide

# Install OpenClaw
pip install openclaw

# Install Formative Memory plugin
pip install openclaw-formative-memory

# Initialize a new agent
from openclaw import Agent
from formative_memory import FormativeMemory

agent = Agent(
    name="HomeAssistant",
    llm="gpt-4",
    plugins=[FormativeMemory()]
)

# Run the agent
agent.run()

For detailed configuration options (token budget, memory size, etc.), refer to the official GitHub repository.

Read more