Idea: Add Portable Experience Memory So Agents Can Learn From Previous Wor

[kaushal trivedi (Kaushalt2004)]

AI agents can maintain conversation/session state, but the useful experience gained while completing a task is difficult to reuse across future tasks or different agents.

For example, an agent may spend 30 minutes debugging an issue, try several approaches, discover why they failed, and eventually find a working solution. Once that execution is over, the next agent often has to rediscover the same solution.

This becomes especially important in multi-agent workflows. One agent may discover something valuable that another agent could immediately benefit from, but there is no standardized way to transfer that experience.

I think there is a difference between remembering conversation history and remembering experience.

Conversation history tells an agent what was said.

Experience tells an agent what was tried, what failed, what worked, and what can be reused.

I would like to see an optional Experience Memory abstraction in Microsoft Agent Framework.

After completing a task, an agent could produce a structured experience record containing things such as:

• Task/problem
• Context
• Actions attempted
• Failed approaches
• Successful approach
• Outcome
• Evidence/verification
• Confidence
• Relevant tools/environment

For example:

Problem:
Database connection failures

Attempt 1:
Increase timeout → failed

Attempt 2:
Change connection pool → failed

Attempt 3:
Fix connection lifecycle → successful

Verified:
Tests passed

This experience could then be stored and made available to future agents.

The interesting part is cross-agent transfer:

Agent A
↓
Solves problem
↓
Experience Memory
↓
Agent B
↓
Retrieves relevant experience
↓
Avoids repeating failed approaches

In a multi-agent workflow, experiences could therefore become a shared learning layer rather than every agent independently rediscovering the same solutions.

This would not require transferring model weights or exposing hidden chain-of-thought. The transferable unit would be structured, user-visible experience derived from completed work.

I think this could complement the existing session/state capabilities of Agent Framework by adding a longer-term layer focused on reusable experience rather than conversation state.

A software team has several agents working on the same codebase.

Agent A is assigned a difficult production bug.

It tries three approaches. Two fail and one works.

The successful solution is verified with tests and stored as an experience.

A week later, Agent B receives a similar bug.

Instead of starting from scratch, the framework retrieves the previous experience:

"Similar issue was solved previously. These two approaches failed. This approach worked because the connection lifecycle was incorrect."

Agent B verifies the information against the current codebase and uses it as a starting point.

If the solution works again, the experience becomes stronger.

If it fails, the experience can be marked as outdated or lower-confidence.

Over time, the team's agents accumulate validated engineering experience that can be reused across sessions and agents.

I've been experimenting with this concept in CogniCore, an open-source cognitive infrastructure project:

https://github.com/cognicore-dev/cognicore-my-openenv

I'm particularly interested in feedback from the Agent Framework community on whether this should be a framework-level abstraction and what the right representation for transferable agent experience would be.