IBM Agent Memory: Persistence and Shared Work Records

IBM offers agent capabilities through several products and frameworks, including the Bee Agent Framework, an open-source TypeScript SDK for building agents, and IBM watsonx Orchestrate, a platform for building and deploying AI assistants in enterprise contexts. Memory behavior differs between them.

What they share is the same general limitation: session-level memory clears when a session ends unless you configure external storage. Durable project context, such as the agreed decisions, active tasks, and standing rules, belongs outside the platform altogether. Tools like fenbs keep that record in a place every connected tool and every person can read.

Memory in the Bee Agent Framework

The Bee Agent Framework, IBM's open-source agent SDK, provides a memory module that manages the messages an agent can access. It includes options for capping the number of retained messages, summarizing older history, and retrieving semantically relevant past exchanges using a vector store.

Memory in Bee is in-process by default: when the agent process ends, in-memory stores clear. The framework supports connecting external stores for persistence, which requires setting up and maintaining that infrastructure separately.

The framework is open source, so you can inspect the actual memory implementation for the version you are using. Check the project's documentation rather than relying on descriptions that may have changed. The open-source location is the primary source for current API details.

Memory in watsonx Orchestrate

watsonx Orchestrate is a managed platform for building AI assistants and workflows in enterprise settings. Conversation context is maintained within a session. Across sessions, persistence depends on how the application is configured, and the platform's capabilities in this area change over time.

watsonx Orchestrate integrates with other IBM data services including Db2, Watson Discovery, and watsonx.data, which can serve as retrieval sources for an agent. These are knowledge retrieval systems, not session memory: they give the agent access to documents and databases, but they do not record what happened in a run.

Configuring external storage for the Bee Agent Framework

The Bee Agent Framework supports plugging in external memory adapters. To persist conversation history across runs, you implement or use a provided adapter that serializes the message sequence to a storage backend of your choice. The adapter receives messages as they are added and makes the full history available on the next initialization.

Keep the adapter's write logic simple and its failure mode loud. If the adapter fails to write a message, the agent should log the failure and continue rather than silently proceeding on a partial history. On the read side, verify that the loaded history matches the expected shape before passing it to the agent. A malformed history can produce confusing behavior that is hard to trace back to a storage error. Add a type check and a schema validation step at load time and surface any mismatch as an explicit error rather than allowing the agent to run on garbage input.

How to test what survives a run

The reliable test is behavioral. Start an agent session, provide a specific fact — a decision, a rule, a step that was completed — then end the session. Start a new session with the same agent and ask a question whose correct answer depends on that fact. If the agent does not know it, that information does not survive the session boundary.

Run the same test with a specific detail from early in a long session. If the answer becomes less accurate as the conversation grows, the memory system is summarizing or truncating older context. Knowing the boundary helps you decide what must be stored externally.

For patterns for building reliable memory across any framework, see how to build agent memory. For security considerations specific to what agent memory stores, see agent memory security.

What to keep outside the platform

Project tasks, decisions that people made, standing rules, and the current state of a body of work are all vendor-neutral facts. Keeping them inside any single platform makes them invisible to other tools, inaccessible to other team members, and dependent on that platform remaining available.

These facts also age differently from conversational memory. A decision to use a specific API stays valid for months. The most recent message in a session is relevant for minutes. Mixing them in the same memory system creates maintenance problems as the long-lived facts get buried or summarized.

How to do this with fenbs

1. Create a free account and add the project your IBM agents support.
2. Add the project's decisions and rules to fenbs with the person who set each one. Mark them as standing rules if they apply to every session.
3. Add the active tasks with their current state so agents start from an accurate picture of the work.
4. After each significant agent run, record what was completed and what remains in fenbs.
5. Connect a supported AI tool over MCP from Integrations to load the project context at the start of each session.

For how memory connects to the retrieval tools IBM offers, see agent memory vs RAG. For multi-agent patterns where memory must be shared across agents, see agent memory MCP.