Persistent Memory
for Microsoft AutoGen

The Multi-Agent Memory Problem

AutoGen orchestrates conversations between multiple AI agents — an AssistantAgent, a UserProxyAgent, a GroupChat with specialized roles. These agents can write code, execute tasks, and debate solutions collaboratively. But when the run completes, every agent's accumulated knowledge disappears.

Consider a typical AutoGen workflow: a research agent gathers data, an analyst agent processes it, and a writer agent produces a report. The next time you run this workflow, the research agent rediscovers the same sources, the analyst re-derives the same conclusions, and the writer ignores all the style refinements from previous runs. Hours of agent computation are wasted repeating work.

The problem is compounded in production systems. AutoGen agents deployed for recurring tasks — daily reports, ongoing research, continuous monitoring — need to build on previous runs rather than restarting from zero each time. Without persistent memory, multi-agent systems cannot develop the institutional knowledge that makes them truly valuable.

Integrating PersistMemory with AutoGen

PersistMemory integrates with AutoGen through custom function tools that agents can call during their conversations. Each agent in your GroupChat can store observations and retrieve past context, building shared memory across the entire agent team.

from autogen import AssistantAgent, UserProxyAgent
import requests

PERSIST_API = "https://backend.persistmemory.com"
API_KEY = "YOUR_API_KEY"
SPACE = "autogen-research"

def store_memory(content: str, category: str = "general") -> str:
    """Store an observation or finding for future runs."""
    requests.post(
        f"{PERSIST_API}/mcp/addMemory",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "title": category, "text": content,
            
            "space": SPACE
        }
    )
    return "Memory stored successfully."

def recall_memory(query: str, limit: int = 5) -> str:
    """Search past memories for relevant context."""
    resp = requests.post(
        f"{PERSIST_API}/mcp/search",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params={"q": query,  "limit": limit}
    )
    results = resp.json().get("results", [])
    if not results:
        return "No relevant memories found."
    return "\n".join(
        f"- {r['content']}" for r in results
    )

# Create memory-aware AutoGen agent
assistant = AssistantAgent(
    name="research_agent",
    system_message="""You are a research agent with
    persistent memory. Always search memory first before
    starting new research. Store important findings.""",
    llm_config={"model": "gpt-4o"},
)

# Register memory tools
assistant.register_function(
    function_map={
        "store_memory": store_memory,
        "recall_memory": recall_memory,
    }
)

Shared Memory Across Agent Teams

PersistMemory's isolated memory spaces are ideal for AutoGen's GroupChat pattern. Create a shared memory space for the entire agent team, so the research agent's findings are immediately available to the analyst and writer agents. Or create per-agent spaces for specialized knowledge that only certain roles should access.

When an AutoGen GroupChat reconvenes for a follow-up task, each agent can search the shared memory space to recall what the team accomplished previously. The research agent finds its past sources. The analyst recalls its previous conclusions. The writer remembers the formatting preferences that were established. The entire team picks up where it left off.

This pattern transforms AutoGen from a stateless orchestration tool into a system that develops genuine expertise over time. Agent teams become more efficient and produce higher-quality results with each run because they build on accumulated knowledge rather than starting fresh.

Production AutoGen Memory Patterns

Daily Reporting Agents: An AutoGen team that generates daily business reports stores key metrics, trends, and anomalies in PersistMemory. Each report references previous findings, tracks changes over time, and highlights meaningful deviations — impossible without cross-run memory.

Code Review Teams: A GroupChat with a security auditor, style checker, and architecture reviewer builds institutional knowledge about your codebase. The agents remember past vulnerabilities, established patterns, and team conventions across every PR they review.

Customer Research: Agents that analyze customer feedback, support tickets, and usage patterns accumulate understanding over time. They identify recurring themes, track sentiment shifts, and build a comprehensive customer intelligence layer.

Learning Agents: AutoGen agents that learn from their mistakes — storing failed approaches and successful strategies in PersistMemory — converge on optimal solutions faster with each run. This creates a feedback loop where agents genuinely improve through experience.

Why PersistMemory for AutoGen

PersistMemory provides the exact infrastructure AutoGen agents need: vector-powered semantic search for intelligent retrieval, isolated spaces for multi-tenant deployments, file processing for document-heavy workflows, and a REST API that integrates cleanly with AutoGen's function calling pattern.

Start free with no credit card. Give your AutoGen agents persistent memory in minutes and watch your multi-agent systems become genuinely smarter over time.