Sparsh Jain on Building Experiential Memory for AI Agents

I am Sparsh Jain, head of AI at CentralAgent AI. Teams learn from working with an agent, but the agent may repeat the same mistakes in a new session or with another teammate. A senior executive described that recurring correction as a practical problem: there are too many mistakes to manually fix every time.

The initial response is often to supply all the available context and memory. In our experience, that becomes counterproductive at enterprise scale: more material can increase cost, effort and latency while making retrieval and performance worse. More context is not always better context.

We looked at how people improve through experience, mistakes and course corrections. Our question became how to preserve useful lessons from interactions rather than merely store a larger collection of facts. I describe the resulting architecture as experiential memory.

I distinguish short-term working memory from long-term memory. Long-term memory includes both facts and experience: lessons abstracted from what happened while the agent worked. My team claims a substantial improvement from its system, but the talk does not provide enough experimental detail to generalize the number.

We divide experience into cases, strategies and skills. A case retains details of a particular situation; a strategy records an approach that worked in a situation; a skill is a more generalized procedure that an agent can reuse. These represent different levels of abstraction, not interchangeable storage.

Building the first memory layer exposed another challenge: data, systems and the environment change. A note that was useful today may become stale. Memory infrastructure therefore needs to evolve rather than be built once and left untouched.

I organize the memory lifecycle into formation, updating and retrieval. Formation extracts potential lessons. Updating adds new observations, revises existing notes, deactivates outdated ones and provides a way to forget material that no longer helps.

Keeping only the latest judgment is not always enough. We retain inactive notes as a record of how the judgment changed: a shallow lookup may use active notes, while deeper investigation can also inspect the earlier history. The distinction lets a system examine why a previous conclusion was replaced.

I use the story of a person with unusually strong recall to illustrate why forgetting can matter. The lesson for an agent system is narrower than the analogy: if every old item competes equally for attention, retaining everything can overwhelm the process rather than improve a decision.

After adding memory, much of the upkeep was still manual. I argue that models can help verify proposed updates and make the loop more autonomous. That is a design proposal, not proof that model verification is always correct or that human oversight is never needed.

Retrieval is as important as storage. Imagine asking an agent to navigate home when it knows about homes in two cities. A correct fact is not enough if the system retrieves the wrong one for the current location. Formation and updates cannot compensate for consistently irrelevant retrieval.

In one example, my team says reusing previously gathered context reduced a task from around 20 minutes to around two. We also observed savings in effort and tokens. This is a team-reported example, and the result depends on the task and evaluation conditions.

We call the next part a dreaming cycle: a recurring cleanup and evaluation loop that removes or demotes stale information, updates priorities and reorganizes memory. The sleep analogy describes the role of the loop; the implementation is a process for maintaining stored information.

My three rules are to disclose context progressively rather than dump everything, keep improving the system as conditions change, and build feedback loops rather than relying only on a fixed prompt. Observability and evaluation surround the memory lifecycle so proposed changes can be tested before use.

I expect teams to benefit when lessons from different users become available to the same agent. I also predict much more autonomous human-agent collaboration. Claims of tenfold or hundredfold teams and exponential improvement are my projections, not demonstrated universal outcomes.

The takeaway is to build a way for agents to learn from corrections instead of repeating the same mistakes. That requires selective memory, updates, retrieval, evaluation and safeguards working together.