Multi-Agent Memory

Multi-Agent Memory gives all agents in a workflow access to shared memory, so knowledge discovered by one agent is available to others.

from praisonaiagents import Agent, Task, PraisonAIAgents, MultiAgentMemoryConfig

researcher = Agent(name="Researcher", instructions="Research topics and share findings.")
writer = Agent(name="Writer", instructions="Write based on shared research.")

tasks = [
    Task(description="Research climate change impacts on agriculture", agent=researcher),
    Task(description="Write a policy brief based on the research", agent=writer),
]

workflow = PraisonAIAgents(
    agents=[researcher, writer],
    tasks=tasks,
    memory=MultiAgentMemoryConfig(user_id="project_climate", config={"provider": "rag"}),
)
workflow.start()

The user runs a multi-agent workflow; all agents read and write shared memory under one user id.

Quick Start

Simple Usage

from praisonaiagents import Agent, Task, PraisonAIAgents, MultiAgentMemoryConfig

agent1 = Agent(name="Gatherer", instructions="Gather and remember information.")
agent2 = Agent(name="Synthesizer", instructions="Synthesize remembered information.")

tasks = [
    Task(description="Gather key facts about solar energy", agent=agent1),
    Task(description="Create a summary from gathered facts", agent=agent2),
]

workflow = PraisonAIAgents(
    agents=[agent1, agent2],
    tasks=tasks,
    memory=MultiAgentMemoryConfig(user_id="solar_project"),
)
workflow.start()

With Custom Embedder

from praisonaiagents import Agent, Task, PraisonAIAgents, MultiAgentMemoryConfig

agents = [
    Agent(name="Expert", instructions="Provide domain expertise."),
    Agent(name="Summarizer", instructions="Summarize expert findings."),
]

tasks = [
    Task(description="Analyze cybersecurity vulnerabilities in cloud systems", agent=agents[0]),
    Task(description="Create an executive summary for non-technical stakeholders", agent=agents[1]),
]

workflow = PraisonAIAgents(
    agents=agents,
    tasks=tasks,
    memory=MultiAgentMemoryConfig(
        user_id="security_review",
        embedder={"provider": "openai", "config": {"model": "text-embedding-3-small"}},
        config={"provider": "rag"},
    ),
)
workflow.start()

Configuration Options

MultiAgentMemoryConfig SDK Reference

Full parameter reference for MultiAgentMemoryConfig

Precedence ladder:

# Level 1: Bool (enable with defaults)
team = PraisonAIAgents(memory=True)

# Level 2: MultiAgentMemoryConfig (full control)
team = PraisonAIAgents(memory=MultiAgentMemoryConfig(
    user_id="user-123",
    embedder={"provider": "openai"},
))

Option	Type	Default	Description
`user_id`	`str \| None`	`None`	Scope memory to a specific user or project
`embedder`	`Any \| None`	`None`	Embedder configuration (e.g., `{"provider": "openai"}`)

How It Works

Phase	What happens
1. Store	First agent saves discoveries to shared memory
2. Retrieve	Subsequent agents access all stored context
3. Build	Later agents build on earlier agents’ work

Configuration Options

Full list of options, types, and defaults — MultiAgentMemoryConfig

Option	Type	Default	Description
`user_id`	`str \| None`	`None`	Shared user/project identifier for scoped memory
`embedder`	`Any \| None`	`None`	Embedder configuration for semantic memory
`config`	`dict \| None`	`None`	Memory provider configuration

Common Patterns

Pattern 1 — Project-scoped research memory

from praisonaiagents import Agent, Task, PraisonAIAgents, MultiAgentMemoryConfig

agents = [
    Agent(name="Researcher", instructions="Research and document findings."),
    Agent(name="Analyst", instructions="Analyze documented findings."),
    Agent(name="Reporter", instructions="Create final reports."),
]

tasks = [
    Task(description="Research market trends in renewable energy", agent=agents[0]),
    Task(description="Identify key investment opportunities from research", agent=agents[1]),
    Task(description="Write an investment recommendation report", agent=agents[2]),
]

result = PraisonAIAgents(
    agents=agents,
    tasks=tasks,
    memory=MultiAgentMemoryConfig(user_id="renewable_energy_2025"),
).start()
print(result)

Best Practices

Always set user_id for project isolation

Set user_id to a unique project or session identifier to prevent memory from bleeding between unrelated workflows. Without user_id, all workflows share the same memory namespace.

Agents that intentionally share a user_id write safely under one process — see Concurrency and shared user_id.

Order tasks to build context

Tasks run in order by default. Place information-gathering tasks first and synthesis/writing tasks later so downstream agents have full context from upstream agents.

Isolating collections per agent

When several agents share one rag_db_path, give each a distinct collection_name so they coexist and can be reset independently.

from praisonaiagents import Agent

researcher = Agent(
    name="Researcher",
    memory={
        "provider": "rag",
        "rag_db_path": "./chroma_db",
        "collection_name": "researcher_ltm",
    },
)

writer = Agent(
    name="Writer",
    memory={
        "provider": "rag",
        "rag_db_path": "./chroma_db",
        "collection_name": "writer_ltm",
    },
)

# researcher.memory.reset_long_term() no longer wipes writer's memory.

collection_name defaults to "memory_store". See Memory Configuration.

Concurrency and shared user_id

When multiple agents share the same user_id and back FileMemory (or the file-backed learn store) on the same paths, concurrent writes are now merge-safe: each mutation re-reads the on-disk state under the instance lock before appending, so two agents recording facts against the same user_id no longer overwrite each other’s entries. This applies to add_short_term, add_long_term, add_entity, auto-promotion to long-term memory, and learn/stores.py BaseStore.add. This is a bug fix, not a new API — no configuration change is required. If you previously worked around lost writes by serializing agent runs or by giving agents distinct user_ids, you can remove that workaround where sharing was actually the goal.

File-based memory serializes writes per-process. If you run agents across separate processes on the same on-disk memory files, the per-process lock does not cover cross-process races — use per-process user_id scoping or a shared memory provider (RAG/graph) for cross-process sharing.

For hierarchical runs that share memory, see how the hierarchical process surfaces the final worker task’s output.

Advanced Memory

Single-agent memory configuration

Multi-Agent Planning

Plan tasks before executing them

Multi-Agent Hooks

Intercept task lifecycle events

Learn

Continuous learning from conversations

Getting Started

Install

Core Concepts

Guides

Features

Models

Databases

Observability

Memory

Telemetry & Analytics

Knowledge

RAG

Persistence

Tools

Other Features

Developers

Configuration

Best Practices

Getting Started (No Code)

Multi-Agent Memory

Quick Start

Configuration Options

MultiAgentMemoryConfig SDK Reference

How It Works

Configuration Options

Common Patterns

Pattern 1 — Project-scoped research memory

Best Practices

Isolating collections per agent

Concurrency and shared user_id

Advanced Memory

Multi-Agent Planning

Multi-Agent Hooks

Learn

​Quick Start

​Configuration Options

MultiAgentMemoryConfig SDK Reference

​How It Works

​Configuration Options

​Common Patterns

​Pattern 1 — Project-scoped research memory

​Best Practices

​Isolating collections per agent

​Concurrency and shared user_id

​Related

Advanced Memory

Multi-Agent Planning

Multi-Agent Hooks

Learn

Quick Start

Configuration Options

How It Works

Configuration Options

Common Patterns

Pattern 1 — Project-scoped research memory

Best Practices

Isolating collections per agent

Concurrency and shared user_id

Related