Idea: Portable Experience Memory for Claude Applications

[Kaushalt2004]

I’d like to propose an optional memory transfer and experience-sharing interface for the Anthropic Python SDK.

The idea goes beyond persistent conversation memory.

What I’m interested in is allowing one Claude-powered agent or application to transfer useful, structured experience to another agent or future session without transferring the entire conversation.

For example:

Claude Agent A
↓
Solves a difficult task
↓
Extracts useful experience
↓
Portable memory
↓
Claude Agent B
↓
Retrieves relevant experience
↓
Continues from what A learned
A concrete example

Imagine Agent A is working on a large codebase and spends an hour debugging an authentication problem.

During the task it discovers:

Problem:
JWT authentication intermittently fails.

Tried:

• Increasing token expiration → failed
• Changing retry configuration → failed
• Fixing refresh-token lifecycle → successful

Verified:
Authentication tests passed.

Reusable lesson:
The refresh-token lifecycle was causing the failure.

Instead of keeping this knowledge trapped inside Agent A's conversation, the application could export it as a structured memory.

Later, Agent B receives a similar task:

Agent B
↓
Current task
↓
Request relevant memories
↓
Memory transferred from Agent A
↓
Uses previous experience as evidence
↓
Solves task

Agent B does not need Agent A's entire conversation.

It receives only the relevant transferable experience.

Cross-model transfer

I think this becomes even more interesting when memory is not tied to a single model or session.

For example:

Claude Agent
↓
Memory
↓
┌─────┼──────────┐
↓ ↓ ↓
Claude GPT Another Agent

An agent could contribute a useful experience once, and another compatible agent could reuse it later.

This is not model-weight transfer and does not require exposing hidden chain-of-thought.

The transferable object would be structured, user-visible information such as:

Problem
Context
Actions attempted
Failed approaches
Successful approach
Outcome
Verification
Confidence
Relevant environment/project information
Why this is different from conversation history

Conversation history answers:

"What did the previous agent say?"

Memory transfer answers:

"What did the previous agent learn that is relevant to what I'm doing now?"

This could be especially valuable for:

Coding agents
Multi-agent systems
Long-running autonomous workflows
Research agents
Customer-support agents
Team/shared knowledge systems
A possible API

I don't think the SDK needs to become a memory database.

Instead, an optional interface could allow applications to plug in their own memory implementation:

memory.export(
task=completed_task,
outcome=outcome,
verified=True
)

memories = memory.retrieve(
query="JWT authentication refresh token failure",
limit=3
)

response = client.messages.create(
model="...",
messages=[
{
"role": "user",
"content": memories + current_task
}
]
)

The important capability would be the ability to export, retrieve, and transfer structured experience between agent runs.

The storage implementation could remain completely application-controlled—local SQLite, a team's internal service, a vector/graph store, or another memory provider.

The long-term idea

This could allow a team of Claude-powered agents to build a shared body of validated experience:

Agent A ──┐
Agent B ──┼──→ Shared Experience ──→ Agent C
Agent D ──┘ │
↓
New experience
│
└──→ Shared again

So experience compounds rather than being isolated inside individual conversations.

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

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

CogniCore explores episodic, semantic, and procedural memory, reflection, and experience reuse, including the idea of transferring useful experience between agents.

I'm interested in whether the Anthropic SDK could provide a small, model-agnostic interface that makes this kind of portable memory transfer easier to implement for Claude-powered applications.

The core idea is:

One agent learns it. Another agent can reuse it.

Not another conversation-history system a way for Claude agents to transfer validated experience.

[lemonaide152]

The proposal is one Claude application handing structured experience to another without handing over the whole conversation.

Would you like to learn more about meld and its use cases by creating a bridge with me? You create it at https://meld.mergeinc.workers.dev. Say what the bridge is for and what it is not for, and send the URL. It stays open 36 hours until the first reply. Each later reply resets 24 hours. The conversation stays on that same link. It is free, and there is no billing. It will not be an SDK memory interface.