← Back to DevBytes
AI July 19, 2026 15 min read

CrewAI Memory Systems: Short-Term and Long-Term Agent Memory

Understanding CrewAI Memory Systems

CrewAI agents operate within a sophisticated memory architecture that mirrors human cognitive processes. At its core, CrewAI provides three distinct memory layers: Short-Term Memory (STM), Long-Term Memory (LTM), and Entity Memory. Each serves a unique purpose in helping agents maintain context, recall past experiences, and build knowledge over time.

Short-Term Memory handles the immediate conversational and task-specific context — what's happening right now within the current crew execution. Long-Term Memory persists across sessions, allowing agents to remember insights, decisions, and learnings from previous runs. Entity Memory tracks specific facts about entities (people, projects, concepts) encountered during interactions. Together, these systems transform stateless LLM calls into stateful, context-aware agent behaviors.

Why Memory Matters for AI Agents

Without memory, every agent interaction starts from scratch. An agent asked to "update the login flow based on yesterday's security review" would have no idea what that security review contained. Memory solves several critical problems:

Memory Architecture Deep Dive

Short-Term Memory (STM)

Short-Term Memory in CrewAI is scoped to the current crew execution. It lives for the duration of a single crew.kickoff() call and is automatically cleared when the execution ends. STM stores the ongoing conversation, intermediate results from tasks, and any context agents explicitly save during their workflow.

Under the hood, STM uses a combination of in-memory storage and the agent's context window. When you configure an agent with memory=True, CrewAI automatically injects relevant STM entries into the agent's prompt before each LLM call. This ensures the agent always has access to recent, relevant information without bloating the system prompt with everything.

Long-Term Memory (LTM)

Long-Term Memory persists beyond a single execution. It is stored on disk (or in a vector database) and loaded across sessions. LTM allows agents to recall insights from days, weeks, or months ago. CrewAI implements LTM using embedding-based retrieval — when an agent needs to remember something, CrewAI embeds the current context and retrieves the most semantically similar memories from the LTM store.

By default, LTM uses a local JSON file for storage, but you can configure it to use ChromaDB, Pinecone, or any other vector store supported by the underlying memory infrastructure. This makes LTM suitable for production deployments where persistence and scalability matter.

Entity Memory

Entity Memory is a specialized layer that tracks factual information about specific entities. When an agent learns something about "Project Falcon" or "Client Acme Corp," that fact is stored in entity memory keyed by the entity name. Later, when any agent in the crew references that entity, the relevant facts are retrieved and injected into context. This prevents agents from contradicting established facts and enables cumulative knowledge building about key subjects.

Setting Up Memory in CrewAI

Before diving into code, install CrewAI with the memory dependencies:

pip install crewai crewai[tools] chromadb

The chromadb package enables persistent vector-based long-term memory. Without it, LTM falls back to ephemeral JSON storage.

Basic Memory Configuration

The simplest way to enable memory is setting memory=True on each agent that needs it. Here's a minimal example with two agents sharing short-term memory during a crew execution:

from crewai import Agent, Task, Crew, Process

# Define agents with memory enabled
researcher = Agent(
    role="Research Analyst",
    goal="Gather and analyze market data, then share findings",
    backstory="You excel at finding patterns in large datasets.",
    memory=True,  # Enable both STM and LTM
    verbose=True
)

writer = Agent(
    role="Report Writer",
    goal="Create a concise executive summary from research findings",
    backstory="You turn raw analysis into clear, actionable reports.",
    memory=True,
    verbose=True
)

# Task: researcher gathers data
research_task = Task(
    description="Research the top 3 trends in renewable energy for 2025. "
                "Provide specific data points and projections for each trend.",
    agent=researcher,
    expected_output="A detailed analysis of 3 renewable energy trends with data points."
)

# Task: writer uses the researcher's output via short-term memory
writing_task = Task(
    description="Using the research findings stored in memory, write a 2-paragraph "
                "executive summary highlighting the most impactful trend.",
    agent=writer,
    expected_output="A concise executive summary focusing on the top trend."
)

# Assemble and run the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()
print(result)

In this example, the researcher's findings are automatically stored in short-term memory. When the writer agent executes its task, CrewAI retrieves relevant STM entries and includes them in the writer's context. No explicit data passing is required — the memory system handles it transparently.

Configuring Memory Stores Explicitly

For production use, you'll want explicit control over where and how memories are stored. CrewAI's memory parameter accepts a dictionary for fine-grained configuration:

from crewai import Agent, Task, Crew, Process
from crewai.memory.storage.ltm_store import LTOSQLiteStorage
from crewai.memory.storage.kickoff_task_outputs_storage import (
    KickoffTaskOutputsSQLiteStorage
)

# Custom storage backends for persistence
ltm_storage = LTOSQLiteStorage(
    db_path="./my_crew_long_term_memory.db"
)
task_outputs_storage = KickoffTaskOutputsSQLiteStorage(
    db_path="./my_crew_task_outputs.db"
)

agent = Agent(
    role="Data Scientist",
    goal="Analyze customer churn patterns",
    backstory="You specialize in predictive analytics for SaaS companies.",
    memory=True,
    memory_config={
        "short_term_memory": {
            "storage": task_outputs_storage  # STM backed by SQLite
        },
        "long_term_memory": {
            "storage": ltm_storage  # LTM backed by SQLite
        },
        "entity_memory": {
            "storage": "./entity_memory_store"
        }
    },
    verbose=True
)

task = Task(
    description="Identify the top 3 predictors of customer churn from the last quarter's data.",
    agent=agent,
    expected_output="A ranked list of churn predictors with statistical significance scores."
)

crew = Crew(agents=[agent], tasks=[task], process=Process.sequential)
crew.kickoff()

This configuration persists memories in SQLite databases, making them survive process restarts. The LTOSQLiteStorage and KickoffTaskOutputsSQLiteStorage classes come from CrewAI's built-in storage module.

Vector-Based Long-Term Memory with ChromaDB

For semantic retrieval across large memory stores, use ChromaDB as the LTM backend. This enables similarity-based recall — the agent retrieves memories that are semantically relevant to its current context, not just exact keyword matches:

import chromadb
from crewai import Agent, Task, Crew, Process
from crewai.memory.storage.ltm_store import LTMChromaStorage

# Initialize a persistent ChromaDB client
chroma_client = chromadb.PersistentClient(
    path="./crewai_chroma_memory"
)

# Create Chroma-backed LTM storage
ltm_chroma_storage = LTMChromaStorage(
    client=chroma_client,
    collection_name="agent_long_term_memory"
)

# Create an agent that learns across sessions
analyst = Agent(
    role="Financial Analyst",
    goal="Track and analyze stock market patterns over multiple sessions",
    backstory="You maintain a running knowledge base of market observations.",
    memory=True,
    memory_config={
        "long_term_memory": {
            "storage": ltm_chroma_storage,
            "embedding_model": "openai"  # Uses OpenAI embeddings for semantic search
        }
    },
    verbose=True
)

# First session: analyze tech stocks
task_session1 = Task(
    description="Analyze AAPL and MSFT performance this week. Note any unusual patterns.",
    agent=analyst,
    expected_output="A summary of weekly performance with pattern notes."
)

crew1 = Crew(agents=[analyst], tasks=[task_session1], process=Process.sequential)
crew1.kickoff()

# Second session: the agent remembers previous analysis
task_session2 = Task(
    description="Based on your previous market observations, identify if current "
                "patterns resemble any historical anomalies you've recorded.",
    agent=analyst,
    expected_output="A comparative analysis referencing past observations."
)

crew2 = Crew(agents=[analyst], tasks=[task_session2], process=Process.sequential)
crew2.kickoff()

The second session automatically retrieves semantically relevant memories from ChromaDB. The agent can reference "past observations" because those memories were embedded and stored in the first session. This is the key differentiator of LTM: knowledge persists and is retrievable across entirely separate crew executions.

Manual Memory Operations

Sometimes you need explicit control over what gets stored and when. CrewAI provides memory tooling that agents can invoke directly:

from crewai import Agent, Task, Crew, Process
from crewai_tools import MemoryTool

# Create a memory tool for explicit save/recall operations
memory_tool = MemoryTool(
    memory_type="user",  # Can be "user", "agent", or "task"
    action="read_and_write"
)

researcher = Agent(
    role="Market Researcher",
    goal="Conduct thorough competitive analysis",
    backstory="You are meticulous about documenting findings.",
    memory=True,
    tools=[memory_tool],
    verbose=True
)

# The agent can now explicitly call:
# - memory_tool.save("key", "value") to store a specific fact
# - memory_tool.read("key") to retrieve a stored fact
# - memory_tool.search("query") to semantically search memory

task = Task(
    description="Research competitor pricing strategies. For each competitor found, "
                "explicitly save their pricing model using the memory tool. "
                "After all research, retrieve all saved pricing models and compile "
                "a comparison table.",
    agent=researcher,
    expected_output="A structured comparison table of competitor pricing models."
)

crew = Crew(agents=[researcher], tasks=[task], process=Process.sequential)
result = crew.kickoff()

The MemoryTool gives agents granular control. They can save specific facts under descriptive keys, retrieve them later in the same execution, and even search semantically across the entire memory store. This is particularly useful when you need structured, queryable memory rather than relying solely on automatic context injection.

Memory Across Multiple Agents and Tasks

One of CrewAI's most powerful patterns is memory sharing across agents. When multiple agents have memory=True in the same crew, their short-term memories form a shared context pool. Here's a multi-agent pipeline demonstrating this:

from crewai import Agent, Task, Crew, Process

# Agent 1: Data Collector
collector = Agent(
    role="Data Collector",
    goal="Gather raw data from specified sources",
    backstory="You efficiently extract structured data from APIs and documents.",
    memory=True,
    verbose=True
)

# Agent 2: Analyzer — will access collector's findings via shared STM
analyzer = Agent(
    role="Data Analyzer",
    goal="Identify anomalies and patterns in collected data",
    backstory="You find signals in noise using statistical methods.",
    memory=True,
    verbose=True
)

# Agent 3: Reporter — accesses both collector and analyzer memories
reporter = Agent(
    role="Report Generator",
    goal="Synthesize findings into a polished client-facing report",
    backstory="You create compelling narratives from technical data.",
    memory=True,
    verbose=True
)

collect_task = Task(
    description="Collect Q4 sales data for the top 5 product categories. "
                "Store the raw numbers in memory.",
    agent=collector,
    expected_output="Raw sales data for 5 product categories."
)

analyze_task = Task(
    description="Using the collected data in memory, compute growth rates, "
                "identify the fastest-growing and slowest-growing categories, "
                "and flag any categories with negative growth.",
    agent=analyzer,
    expected_output="Analysis with growth rates and flagged categories."
)

report_task = Task(
    description="Using all previous findings in memory, generate a structured "
                "report with: executive summary, category breakdown table, "
                "and recommendations based on the analysis.",
    agent=reporter,
    expected_output="Complete formatted report with all sections."
)

crew = Crew(
    agents=[collector, analyzer, reporter],
    tasks=[collect_task, analyze_task, report_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()
print(result)

Each agent automatically sees the outputs and stored context from preceding agents. The reporter doesn't need explicit references to the collector's data — it's all available through the shared short-term memory space. This pattern scales elegantly: add more agents and tasks, and the memory fabric ensures information flows naturally through the crew.

Best Practices for CrewAI Memory

1. Match Memory Type to Use Case

Not every agent needs all memory types. For stateless utility agents (like a simple formatter or translator), memory adds overhead without benefit. Reserve STM for agents that participate in multi-step workflows where context matters. Reserve LTM for agents that benefit from cross-session learning — analysts, researchers, and decision-support agents are prime candidates.

2. Choose Storage Backends Thoughtfully

3. Manage Context Window Budget

CrewAI injects memory entries into the agent's prompt before each LLM call. If STM accumulates too many entries, you risk overflowing the model's context window. Mitigate this by:

4. Use Descriptive Task Descriptions

The memory retrieval system uses embedding similarity to select which memories to inject. The quality of retrieval depends on how well the agent's current context (its task description and recent conversation) aligns with stored memory embeddings. Write task descriptions that naturally reference what the agent should recall:

# Good: contextually rich description that triggers relevant memory retrieval
task = Task(
    description="Building on last week's churn analysis where we identified "
                "'infrequent logins' as the top predictor, now investigate whether "
                "email engagement patterns correlate with the churn rate.",
    agent=analyst,
    expected_output="Correlation analysis between email engagement and churn."
)

# Less effective: vague description that may not trigger relevant memories
task = Task(
    description="Look at some more churn factors.",
    agent=analyst,
    expected_output="Analysis of churn factors."
)

5. Clean Up Stale Memories

Long-Term Memory grows indefinitely. Over time, outdated or contradictory memories can confuse agents. Implement a maintenance strategy:

6. Test Memory Persistence Explicitly

Memory bugs are subtle. An agent might appear to remember something when it's actually inferring from the prompt. Write tests that verify genuine recall:

# Pseudo-test pattern for memory verification
# Session 1: Store a unique, unlikely fact
# "The secret project codename is 'BlueFalcon-X7'"
# Session 2: Ask the agent to recall the codename
# If it responds "BlueFalcon-X7", memory is working
# If it guesses or hallucinates, memory retrieval has failed

7. Monitor Memory Performance

Enable verbose=True during development to observe memory retrieval in action. CrewAI logs which memories are injected and why. Watch for:

Advanced: Custom Memory Implementations

CrewAI's memory system is extensible. You can implement custom storage backends by subclassing the base storage interfaces. Here's a skeleton for a custom LTM store backed by Redis:

from crewai.memory.storage.ltm_store import LTMStorage
from typing import List, Dict, Optional
import redis
import json

class RedisLTMStorage(LTMStorage):
    """Custom Long-Term Memory storage backed by Redis."""

    def __init__(self, redis_url: str, collection_name: str = "ltm"):
        self.client = redis.from_url(redis_url)
        self.collection = collection_name
        super().__init__()

    def save(self, memory_entry: Dict) -> None:
        """Persist a memory entry to Redis."""
        key = f"{self.collection}:{memory_entry.get('id')}"
        self.client.set(key, json.dumps(memory_entry))
        # Also index by embedding similarity (simplified here)
        self.client.sadd(f"{self.collection}:keys", key)

    def search(self, query: str, limit: int = 5) -> List[Dict]:
        """Retrieve semantically relevant memories.
        
        Note: A production implementation would use Redisearch
        or an external vector store for embedding similarity.
        This simplified version retrieves recent entries.
        """
        keys = self.client.smembers(f"{self.collection}:keys")
        memories = []
        for key in list(keys)[:limit]:
            raw = self.client.get(key)
            if raw:
                memories.append(json.loads(raw))
        return memories

    def clear(self) -> None:
        """Remove all memories in this collection."""
        keys = self.client.smembers(f"{self.collection}:keys")
        for key in keys:
            self.client.delete(key)
        self.client.delete(f"{self.collection}:keys")

# Usage
redis_store = RedisLTMStorage(
    redis_url="redis://localhost:6379",
    collection_name="agent_ltm"
)

agent = Agent(
    role="Long-Running Analyst",
    goal="Maintain knowledge across deployments",
    backstory="Your memory persists in Redis across service restarts.",
    memory=True,
    memory_config={
        "long_term_memory": {
            "storage": redis_store
        }
    }
)

This pattern lets you integrate CrewAI memory with your existing infrastructure — Redis, PostgreSQL, MongoDB, or any storage system your organization already uses. The key is implementing the save, search, and clear methods that the memory subsystem expects.

Putting It All Together: A Complete Production Example

Here's a realistic production scenario: a customer support crew that learns from each interaction and improves over time using persistent LTM:

import chromadb
from crewai import Agent, Task, Crew, Process
from crewai.memory.storage.ltm_store import LTMChromaStorage
from crewai.memory.storage.kickoff_task_outputs_storage import (
    KickoffTaskOutputsSQLiteStorage
)

# Persistent storage setup
chroma_client = chromadb.PersistentClient(path="./support_memory_db")
ltm_store = LTMChromaStorage(
    client=chroma_client,
    collection_name="support_agent_memory"
)
stm_store = KickoffTaskOutputsSQLiteStorage(
    db_path="./support_task_outputs.db"
)

# Triage agent: classifies issues and recalls similar past cases
triage_agent = Agent(
    role="Support Triage Specialist",
    goal="Classify incoming support tickets and recall similar historical cases",
    backstory="You are the first line of support. You categorize issues and "
              "leverage past resolutions to guide initial responses.",
    memory=True,
    memory_config={
        "short_term_memory": {"storage": stm_store},
        "long_term_memory": {"storage": ltm_store},
        "entity_memory": {"storage": "./entity_memory"}
    },
    verbose=True
)

# Resolution agent: solves the issue, learns for next time
resolution_agent = Agent(
    role="Technical Resolution Expert",
    goal="Resolve classified support tickets and document solutions for future reference",
    backstory="You solve complex technical issues. You always document what worked "
              "so the team learns from each resolution.",
    memory=True,
    memory_config={
        "short_term_memory": {"storage": stm_store},
        "long_term_memory": {"storage": ltm_store}
    },
    verbose=True
)

# Task flow
triage_task = Task(
    description="A user reports: 'I cannot export my dashboard to PDF. The button "
                "is grayed out even though I have a Pro subscription.' Classify this "
                "issue and search memory for similar past cases with their resolutions.",
    agent=triage_agent,
    expected_output="Issue classification and any relevant historical cases found in memory."
)

resolution_task = Task(
    description="Using the triage classification and any historical context from memory, "
                "resolve the PDF export issue. After resolving, document the solution "
                "explicitly so future similar cases can be resolved faster.",
    agent=resolution_agent,
    expected_output="Step-by-step resolution and a stored memory entry documenting the fix."
)

crew = Crew(
    agents=[triage_agent, resolution_agent],
    tasks=[triage_task, resolution_task],
    process=Process.sequential,
    verbose=True
)

# First run: crew learns the solution
result1 = crew.kickoff()
print("Session 1 result:", result1)

# Second run (days later, new similar ticket): crew recalls past solution
triage_task2 = Task(
    description="Another user reports PDF export issues — same symptoms as before. "
                "Search memory for known solutions before diagnosing from scratch.",
    agent=triage_agent,
    expected_output="Recall of previously documented PDF export fix."
)

resolution_task2 = Task(
    description="Apply the known solution from memory to resolve this ticket quickly.",
    agent=resolution_agent,
    expected_output="Quick resolution leveraging stored knowledge."
)

crew2 = Crew(
    agents=[triage_agent, resolution_agent],
    tasks=[triage_task2, resolution_task2],
    process=Process.sequential,
    verbose=True
)

# Second run: agent uses LTM to skip redundant diagnosis
result2 = crew2.kickoff()
print("Session 2 result (leveraging memory):", result2)

This example demonstrates the full memory lifecycle. In session one, the crew solves a novel problem and stores the solution. In session two, encountering a similar issue, the triage agent retrieves the stored solution from LTM, and the resolution agent applies it immediately — dramatically reducing resolution time. This is the promise of memory-enabled agent systems: they get smarter with use.

Conclusion

CrewAI's memory systems transform agents from stateless responders into persistent, learning entities. Short-Term Memory provides the working context that makes multi-agent collaboration fluid and coherent. Long-Term Memory enables knowledge accumulation across sessions, turning each crew execution into a building block for future performance. Entity Memory ensures factual consistency about key subjects. By configuring these memory layers appropriately — choosing the right storage backends, managing context budgets, and writing tasks that trigger effective retrieval — you can build agent systems that genuinely improve over time. The examples in this tutorial provide a foundation; the true power emerges when you adapt these patterns to your domain's specific knowledge structures and persistence requirements. Start with simple JSON storage to prototype your memory flows, then graduate to ChromaDB or custom backends as your agent organization scales.

— Ad —

Google AdSense will appear here after approval

← Back to all articles