Skip to content
BranchesTags

Latest commit

 

History

2 Commits

Folders and files

NameName
Last commit message
Last commit date
CONTRIBUTING.md
CONTRIBUTING.md
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

Awesome Agentic Memory

Awesome Stars Forks Contributors Last Commit PRs Welcome License: CC0

The most comprehensive curated list of memory systems, plugins, frameworks, databases, and research for AI agents — across coding, chip design, pharma, healthcare, space exploration, smart agriculture, climate science, and every other domain.

If your agent forgets everything after a session, this list is your cure.

Memory Frameworks · MCP Servers · Agent Frameworks · Coding Agents · Vector DBs · Knowledge Graphs · RAG · Industry Verticals · Research · Benchmarks

Contents

🧠 Why Agentic Memory Matters

Without memory, every AI agent interaction starts from zero. With the right memory layer, agents can:

  • Remember users across sessions, building personalized context over time
  • Accumulate knowledge from past tasks, errors, and successes
  • Reason over time — understand how facts have changed
  • Coordinate in multi-agent systems with shared working memory
  • Scale to production without ballooning token costs

The field has exploded in 2024–2026: from research papers to funded startups to production-grade open-source infrastructure. This list covers all of it.

📊 Memory Framework Comparison

Framework Stars Memory Types Backend MCP Use Case
mem0 ~48k semantic + episodic + KG multi-store ✅ Universal drop-in
Letta ~15k virtual context + core + archival Letta server ✅ Long-running stateful agents
Graphiti (Zep) ~24k temporal knowledge graph Neo4j/FalkorDB/Kuzu ✅ Real-time temporal memory
Cognee ~3k vector + graph + KV multi-backend ✅ 6-line memory setup
LangMem bundled semantic + episodic + procedural LangGraph Store ✅ LangChain/LangGraph agents
Supermemory growing vector + full-text cloud/local ✅ Universal cross-LLM memory
OMEGA growing structured + semantic SQLite ✅ (25 tools) Coding agents
Hindsight growing 4-network biomimetic custom ❌ High-accuracy retrieval
A-MEM growing Zettelkasten + dynamic ChromaDB ❌ Interconnected knowledge nets
claude-mem growing conversation + semantic SQLite ✅ (Claude Code) Claude Code sessions

🗄️ Memory Frameworks & Libraries

mem0

GitHub Stars PyPI Downloads

Universal memory layer combining vector search, knowledge graphs, and key-value storage. 14M+ downloads. $24M Series A. AWS chose it as the exclusive memory provider for their Agent SDK.

from mem0 import Memory

m = Memory()
m.add("I prefer TypeScript over Python for backend work", user_id="alice")
results = m.search("programming preferences", user_id="alice")
# Returns: [{"memory": "Prefers TypeScript over Python for backend", "score": 0.95}]

Letta (formerly MemGPT)

GitHub Stars

OS-inspired virtual memory management for LLMs. Agents maintain core memory (always in context), archival memory (infinite recall), and recall memory (conversation history). The original paper introduced the OS analogy for LLM memory.

from letta import create_client

client = create_client()
agent = client.create_agent(name="my_agent")
# Agent remembers context across sessions automatically
response = client.send_message(agent_id=agent.id, message="My name is Alice")
response2 = client.send_message(agent_id=agent.id, message="What's my name?")
# Returns: "Your name is Alice."

Graphiti (by Zep)

GitHub Stars

Temporal knowledge graph engine where every fact has a validity window. Crossed 20k stars in under 12 months. Outperforms MemGPT on the Deep Memory Retrieval (DMR) benchmark. Has an MCP Server 1.0.

from graphiti_core import Graphiti

graphiti = Graphiti(neo4j_uri, neo4j_user, neo4j_password)
await graphiti.add_episode(
    name="user_preference",
    episode_body="Alice said she prefers TypeScript and dislikes Python for APIs",
    source_description="chat session"
)
results = await graphiti.search("Alice programming preferences")

Cognee

GitHub Stars

ECL (Extract, Cognify, Load) pipeline that combines vector + graph search. Memory in 6 lines of code. $7.5M seed backed by OpenAI and FAIR founders. Graduated from GitHub Secure Open Source Program.

import cognee

await cognee.add("Alice is a senior engineer who joined in 2023")
await cognee.cognify()
results = await cognee.search("Tell me about Alice")

A-MEM (Agentic Memory)

GitHub Stars

Dynamic memory organization following Zettelkasten principles — creates interconnected knowledge networks. NeurIPS 2025. Agents can dynamically index, link, and evolve memory structures.

Supermemory

GitHub Stars

Claims #1 on LongMemEval, LoCoMo, and ConvoMem benchmarks. Extremely fast and scalable. Works across all LLMs with no login required via the MCP server.

OMEGA Memory

GitHub Stars

Persistent memory for AI coding agents. 25 MCP tools. SQLite backend. Auto-capture and auto-surface. Fully local, zero cloud. Claimed 95.4% on LongMemEval.

Hindsight

GitHub Stars

Biomimetic 4-network architecture (world facts, experiences, entity summaries, evolving beliefs). 91.4% on LongMemEval with open-source 20B model.

Memoripy

GitHub Stars

Python library with short/long-term storage, semantic clustering, optional memory decay, and graph-based associations. Supports OpenAI, Azure OpenAI, OpenRouter, Ollama.

MemOS (Memory Operating System)

OS-inspired memory management for LLMs. Multiple active implementations. Redis Streams scheduling, multi-modal memory, persistent skill memory.

ReMe (AgentScope)

Memory Management Kit for Agents — "Remember Me, Refine Me." Token-aware memory management with work memory + personal memory. From Alibaba's AgentScope team. Apache 2.0.

Memori

SQL-native memory layer for LLMs, AI Agents, and multi-agent systems.

SimpleMem

Efficient lifelong memory for LLM agents with minimal overhead.

General Agentic Memory (GAM)

Modular agentic file system framework for structured memory. Supports text and video modalities. Python SDK + CLI + REST API + Web Platform.

MemVid

Single-file memory layer. Sub-5ms local retrieval. +35% SOTA on LoCoMo. Append-only, portable format.

🔌 MCP Memory Servers

Model Context Protocol (MCP) has become the standard for plugging memory into AI tools. Every major memory framework now ships an MCP server.

Server Stars Backend Tools Works With
Official MCP Memory N/A JSON file 9 Any MCP client
mem0 MCP growing mem0 cloud/local 4 Claude, Cursor, any
claude-mem growing SQLite 5 hooks Claude Code
OMEGA MCP growing SQLite 25 Claude Code, Cursor
Graphiti MCP ~24k Neo4j/FalkorDB 8 Claude, Cursor
Supermemory MCP growing cloud 4 Any MCP client
Redis Agent Memory growing Redis 6 Any MCP client
mcp-memory-service growing KG + vector 12 Claude, LangGraph
memory-bank-mcp growing file system 8 Cline, Cursor
neo4j agent memory MCP growing Neo4j 6 Any MCP client
kuzu-memory-graph-mcp growing Kuzu 5 Any MCP client

Official MCP Memory Server

Reference implementation from the MCP team. Knowledge graph-based persistent memory stored in a configurable JSON file. 9 tools: create_entities, add_observations, search_nodes, open_nodes, and more.

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"],
      "env": { "MEMORY_FILE_PATH": "/path/to/memory.json" }
    }
  }
}

mem0 MCP

Wraps the full mem0 memory API as an MCP server. Works with Claude Desktop, Cursor, Windsurf, and any MCP client.

{
  "mcpServers": {
    "mem0": {
      "command": "uvx",
      "args": ["mem0-mcp"],
      "env": { "MEM0_API_KEY": "your-key" }
    }
  }
}

claude-mem

Claude Code plugin that auto-captures everything Claude does, compresses with AI, and injects relevant context into future sessions. 5 lifecycle hooks. SQLite + semantic search.

mcp-memory-service

Open-source persistent memory for AI agent pipelines (LangGraph, CrewAI, AutoGen) and Claude. REST API + knowledge graph + autonomous consolidation. 12 MCP tools.

memory-bank-mcp

MCP server for remote memory bank management, inspired by Cline Memory Bank. Persistent structured context for coding sessions.

Redis Agent Memory Server

Fast and flexible memory for agents using Redis. Working memory with auto-TTL, long-term promotion, background compaction. MCP server interface.

neo4j agent memory MCP

Memory management MCP server for AI agents using Neo4j knowledge graphs. Three memory types: short-term conversation, long-term entity KG, reasoning traces with provenance.

kuzu-memory-graph-mcp

High-performance LLM memory server using Kuzu graph database with semantic search. In-process, sub-3ms recall.

🤖 Agent Frameworks with Memory

LangChain + LangMem

GitHub Stars

LangChain's official agent memory library. Extracts facts from conversations, optimizes prompts over time, maintains long-term memory via LangGraph's Store.

from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()
manage_memory = create_manage_memory_tool(namespace=("user", "alice"))
search_memory = create_search_memory_tool(namespace=("user", "alice"))

AutoGPT

GitHub Stars

The original autonomous agent framework. Goal-driven agents with Pinecone-backed vector memory. Modular memory components for file, Redis, and in-memory storage.

CrewAI

GitHub Stars

Role-playing multi-agent framework with a unified Memory class in OSS 1.0. Four built-in memory types: short-term (ChromaDB + RAG), long-term (SQLite), entity, and procedural.

from crewai import Crew, Agent, Task

crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,           # Enable all memory types
    verbose=True
)

Microsoft AutoGen

GitHub Stars

Microsoft's framework for agentic AI workflows. Pluggable memory components. Being merged with Semantic Kernel into the Microsoft Agent Framework.

Agno (formerly Phidata)

GitHub Stars

Production AI agent framework. Claims 5000x faster instantiation than LangGraph. Built-in session management, long-term user learning storage, 100+ integrations.

from agno.agent import Agent
from agno.memory.v2 import Memory
from agno.storage.sqlite import SqliteStorage

agent = Agent(
    memory=Memory(db=SqliteStorage(table_name="agent_memory")),
    add_history_to_messages=True,
    num_history_runs=5,
)

Mastra

GitHub Stars

TypeScript AI agent framework from the Gatsby team. YC W25, $13M funding. Memory across sessions with libSQL and Postgres backends. 300k+ weekly npm downloads.

import { Memory } from "@mastra/memory";
import { LibSQLStore } from "@mastra/libsql";

const memory = new Memory({
  storage: new LibSQLStore({ url: "file:./memory.db" }),
  options: { lastMessages: 20, semanticRecall: { topK: 5 } }
});

MetaGPT

GitHub Stars

Multi-agent framework that simulates software development roles. Shared memory across agent roles (PM, architect, engineer, QA).

Haystack (deepset)

GitHub Stars

Open-source AI orchestration framework with explicit memory control. InMemoryChatMessageStore, Mem0MemoryStore integration. RAG + agentic workflows.

Flowise

GitHub Stars

Visual AI agent builder with 100+ LLM and vector DB integrations. Conversational agents with built-in memory management via drag-and-drop.

Swarms

Enterprise-grade production-ready multi-agent orchestration. Agent = LLM + Tools + Memory.

AgentVerse

Facilitates deployment of multiple LLM-based agents. Task-solving and simulation frameworks with shared memory.

Julep

Deploy serverless AI workflows. Stateful interactions, persistent memory. (Note: hosted service shut down Dec 2025; self-host works.)

💻 Coding Agent Memory Tools

Memory tools specifically designed for AI coding assistants and developer workflows. Every major AI coding tool now has a memory ecosystem — from built-in context files to MCP plugins to cross-IDE memory layers.

Quick Reference: Memory Support by Tool

Tool Built-in Memory File MCP Support Cross-session Native Memory
Claude Code CLAUDE.md (3-tier) ✅ ✅ (via plugins) ✅ Auto-memory
OpenCode AGENTS.md ✅ ✅ (via plugins) ❌
OpenAI Codex CLI AGENTS.md ✅ ❌ native ✅ SDK sessions
Gemini CLI GEMINI.md ✅ ✅ (ADK) ✅ Conductor ext
Kimi CLI AGENTS.md ✅ ✅ sessions ✅ K2.5 native
Cursor .cursor/rules ✅ ✅ (via MCP) ❌
Windsurf Rules files ✅ ✅ Cascade Memories ✅ Auto-memories
Aider CONVENTIONS.md ✅ ❌ ❌
Continue.dev .continuerc.json ✅ ✅ (via MCP) ❌
Cline Custom instructions ✅ ✅ Memory Bank ❌

Claude Code

Docs

Anthropic's official CLI for Claude. Three-tier file memory + hook system + rich plugin ecosystem. A well-structured CLAUDE.md reduces corrections by ~40% and achieves ~92% rule-application rate when under 200 lines.

Built-in memory hierarchy:

~/.claude/CLAUDE.md          ← global (all projects)
{project-root}/CLAUDE.md     ← project (team-shared, git-tracked)
{project-root}/CLAUDE.local.md ← personal overrides (gitignored)
{subdirectory}/CLAUDE.md     ← directory-specific context

Auto Memory: Claude writes its own notes from corrections and preferences — architecture decisions, build commands, code style, debugging insights. Structured with types: user, feedback, project, reference.

Memory plugins for Claude Code:

Plugin Stars Description Install
claude-mem ~41k Auto-captures all sessions via observer AI; semantic search; 5 lifecycle hooks; SQLite claude mcp add claude-mem
OMEGA growing 25 MCP tools; bge-small embeddings + sqlite-vec; auto-capture + auto-surface; daemon UDS socket omega setup
claude-brain ~174 "Photographic memory" in a single portable .mv2 file; Rust core; sub-ms ops; git-committable MCP
claude-diary growing /diary auto-writes learnings to CLAUDE.md; detects patterns (2+ = pattern, 3+ = strong); hooks into PreCompact Hook-based
claude_memory 8 SQLite + FTS5 + sqlite-vec; fact extraction + truth maintenance; SessionStart/Stop hooks MCP
mcp-memory-keeper growing Persistent context across sessions; preserves work history and decisions MCP
claude-memory-mcp growing TypeScript + SQLite + FTS5; minimal deps; optimal LLM memory techniques MCP
my-claude-code-setup ~1.8k Starter with CLAUDE-*.md memory bank; /init populates from codebase CLAUDE.md
mem0 MCP growing mem0 universal memory + OpenMemory local-first UI claude mcp add mem0
Graphiti MCP ~24k Temporal knowledge graph Docker + config
memorix 144 Cross-IDE (10 tools): git memory + reasoning memory; 22 tools MCP
Official MCP Memory — Reference knowledge graph impl; JSON file backend MCP

Awesome lists:

OpenCode

GitHub Stars

Open-source terminal AI coding agent by SST. Model-agnostic, extensible plugin system, full MCP support. Sessions saved automatically; /sessions to switch.

  • GitHub: https://github.com/sst/opencode
  • Instructions file: AGENTS.md (same as OpenAI Codex, analogous to CLAUDE.md)
  • MCP: Full support — all MCP memory servers work

Memory plugins for OpenCode:

Plugin Description
opencode-supermemory Supermemory plugin; /supermemory-init to memorize codebase conventions; configurable similarity threshold
opencode-mem Local vector DB (SQLite); project memories + user profile learning; multi-provider AI
opencode-agent-memory Letta/MemGPT-inspired; scoped memory blocks with size limits; agent actively maintains own memory
opencode-brain Port of claude-brain; single .mv2 portable file; shares memory with Claude Code
opencode-plugin-simple-memory Lightweight; memories stored as daily logfmt files in .opencode/memory/

Awesome list: awesome-opencode/awesome-opencode

OpenAI Codex CLI + Agents SDK

GitHub Stars

OpenAI's terminal coding agent. Multi-model support with approval workflows. Cross-session memory via the Agents SDK sessions system.

AGENTS.md (Codex's built-in context file):

Discovery order per session:
~/.codex/AGENTS.override.md → ~/.codex/AGENTS.md → {project}/AGENTS.override.md → {project}/AGENTS.md

OpenAI Agents SDK Sessions — persistent memory backends:

from agents import Agent
from agents.sessions import SQLiteSession  # or RedisSession, SQLAlchemySession

agent = Agent(name="coder", instructions="Coding assistant with memory")
session = SQLiteSession("conversations.db")

# Memory persists across .run() calls
result1 = await Runner.run(agent, "My project uses FastAPI", session=session)
result2 = await Runner.run(agent, "What framework should I use?", session=session)
# Returns: "FastAPI, based on your project setup"

Session backends: SQLite (file-based), async SQLite, Redis, SQLAlchemy (Postgres/MySQL), Dapr state store, OpenAI-hosted

Google Gemini CLI + ADK

GitHub Stars

Google's open-source terminal AI agent. 1M token context window. Full MCP support. The ADK provides production-grade memory backends.

Google ADK Memory Services:

from google.adk.agents import Agent
from google.adk.memory import InMemoryMemoryService, VertexAIMemoryBankService

# Prototyping: in-memory, keyword matching
agent = Agent(name="dev_agent", memory_service=InMemoryMemoryService())

# Production: cross-session persistence via Vertex AI
agent = Agent(
    name="dev_agent",
    memory_service=VertexAIMemoryBankService(project="my-project", location="us-central1")
)

Conductor (Context-Driven Development extension):

Shifts development context from transient chats into persistent Markdown files stored in the repository. Defines product goals, architectural constraints, technology choices. Strict lifecycle: Context → Spec → Plan → Implement.

Gemini Code Assist Memory (enterprise + consumer):

  • Persistent memory for coding standards, style, best practices
  • Enabled from Google Cloud Console (enterprise) or Gemini Code Assist site
  • Uses 1M+ token context window

Kimi (Moonshot AI)

GitHub Stars

Chinese frontier model with 256K context and native agent cluster support. The Kimi K2.5 model supports up to 100 parallel agents with shared memory storage/retrieval tools.

  • GitHub (CLI): https://github.com/MoonshotAI/kimi-cli — 6,400+ stars, Apache-2.0
  • Context: 256K tokens; sessions auto-saved; /sessions to view/switch
  • MCP: Full support — kimi mcp add/list/remove/auth
  • API: OpenAI-compatible (mem0, Graphiti work directly)
  • Platform: https://platform.moonshot.ai (agent support, memory storage/retrieval tools)

kimi-code-mcp — delegates bulk codebase analysis to Kimi K2.5 (saving ~90% tokens), with session caching and parallel agents:

Cursor

AI code editor with full MCP support. Memory via .cursor/rules files and any MCP memory server.

All MCP memory servers in this list work with Cursor.

Windsurf (Codeium)

AI-powered IDE with Cascade agentic workflows. Has two complementary memory systems: auto-generated Memories and manual Rules.

  • Cascade Memories (automatic): Auto-generated per interaction; stored in ~/.codeium/windsurf/memories/; workspace-scoped; retrieved when relevant; NOT committed to repo
  • Rules (manual): Globally or workspace-defined standards; version-controlled and shareable
  • MCP: Full support — all MCP memory servers compatible
  • cascade-memory-bank: https://github.com/GreatScottyMac/cascade-memory-bank — Intelligent project memory for Windsurf; maintains context, documents decisions, architectural evolution
  • Docs: https://docs.windsurf.com/windsurf/cascade/memories

Aider

GitHub Stars

AI pair programming in the terminal. Session-stateless but powerful repo-map feature provides structural working memory.

Continue.dev

GitHub Stars

Open-source AI code assistant for VS Code and JetBrains with full MCP support.

# config.yaml
mcpServers:
  - name: memory
    command: docker
    args: ["run", "-i", "--rm", "mcp/memory"]

Cline

VS Code AI coding assistant with full MCP support and the originator of the Memory Bank pattern.

memorix — Cross-IDE Memory Layer

GitHub Stars

Works with 10 IDEs simultaneously: Cursor, Claude Code, OpenAI Codex, Windsurf, Gemini CLI, GitHub Copilot, Kiro, OpenCode, Antigravity, Trae. Git Memory (commits → searchable engineering memory) + Reasoning Memory (stores why decisions were made). 22 MCP tools. Local-first, no API keys.

🗃️ Vector Databases

The storage layer for semantic memory — where embeddings live.

Pinecone

Managed/serverless vector database. Sub-10ms latency at scale. Built-in embeddings (OpenAI, Cohere, E5), rerankers. MCP Agent with list_indexes, upsert, query tools. $130M+ raised.

Qdrant

GitHub Stars

Rust-based. Sophisticated filtering + vector similarity. Best free tier (1GB forever). HNSW indexing. 35+ new integrations in 2025.

Milvus

GitHub Stars

Cloud-native vector DB for massive scale. GPU acceleration, distributed querying. Sub-50ms retrieval on billions of vectors. Used by NVIDIA, Salesforce, eBay.

Weaviate

GitHub Stars

Open-source vector DB with hybrid search + GraphQL. Agent Skills collection for Claude Code, Cursor, Copilot.

Chroma

GitHub Stars

Best for prototyping and small/medium apps. Excellent Python-first API. Default in many agent frameworks (CrewAI, A-MEM).

FAISS

GitHub Stars

Facebook AI's library for efficient similarity search. C++ core with Python + GPU bindings. Indexed 1.5T vectors internally at Meta.

pgvector

GitHub Stars

Open-source vector similarity search for Postgres. HNSW indexing. Native SQL queries over vectors. Foundation for LangGraph production stacks.

pgvectorscale

Postgres extension complementing pgvector with DiskANN for improved performance at scale.

🕸️ Knowledge Graphs

Structured memory with explicit relationships between entities — ideal for temporal and multi-hop reasoning.

Neo4j Agent Memory

Graph-native memory with three types: short-term (conversation), long-term (entity knowledge graph), reasoning (decision traces with provenance).

FalkorDB

Direct successor to RedisGraph. Claims 496x faster P99 latency and 6x better memory efficiency vs Neo4j. Native Graphiti backend.

Memgraph

GitHub Stars

Open-source in-memory graph database. Neo4j-compatible. Built for real-time streaming (Kafka, SQL, CSV). Up to 120x faster than Neo4j.

Kuzu

Embedded property graph DB. Vector + full-text search built in. Cypher. Multiple AI agent memory integrations. In-process, sub-3ms recall.

📚 RAG Frameworks

Retrieval-Augmented Generation — the backbone of long-term knowledge memory.

LlamaIndex

GitHub Stars

Leading document agent platform. Agentic RAG architecture. State, memory, human-in-the-loop review, reflection. Workflows for multi-step pipelines.

RAGFlow

GitHub Stars

Enterprise knowledge base RAG with deep document understanding. Multi-source data analysis. Foundation for production RAG memory systems.

Langflow

GitHub Stars

Low-code builder for RAG and agentic workflows. Visual pipeline orchestration. 130k+ stars.

🏭 Production / Session Storage

For production agents that need fast, reliable memory at scale.

Motorhead

Memory and information retrieval server for LLMs backed by Redis. Configurable MAX_WINDOW_SIZE, auto-summarization when context limit exceeded.

Redis Agent Memory Server

Fast and flexible memory using Redis. Working memory with auto-TTL, long-term promotion, background compaction.

Graphlit

Cloud-native context layer. REST API for durable memory with citations. Real-time sync across Slack, GitHub, Jira.

🏭 Industry Verticals

Memory requirements differ dramatically by domain. This section covers how agentic memory is applied across industries, including domain-specific tools, platforms, and research.

Chip Design & Semiconductors

Memory challenge: EDA workflows span 30+ years of proprietary tapeout data, months-long design cycles, and enormous cross-run learning from simulation sweeps. Agents must encode PPA (performance-power-area) results, tool-aware script memory (Verilog, SystemVerilog, Tcl), and design intent across the full RTL→GDS flow. All three EDA majors (Cadence, Synopsys, Siemens) are now in active agentic AI deployment — not research — as confirmed at DAC 2025.

Tool / Resource Stars Description
ChipNeMo (NVIDIA) — 13B-param domain-adapted LLM trained on 30yr of NVIDIA design docs + Verilog + Tcl; matches LLaMA2-70B on chip tasks at 1/5th the size
VerilogCoder (NVIDIA Labs) growing Graph-based planning + AST waveform tracing; 94.2% on VerilogEval-Human v2
RTL-Coder (HKUST) growing Open-source; outperforms GPT-3.5 on VerilogEval; HKUST
OpenROAD ~2.4k Open-source RTL-to-GDS flow; foundation for LLM agents with design memory
Cadence Cerebrus AI Studio — First multi-block, multi-user AI chip design; AI agents build cross-project PPA models; 5–10x faster delivery
Cadence ChipStack AI Super Agent — Acquired Nov 2025; integrates Cerebrus + Verisium + JedAI data platform; used in 1,000+ tapeouts
Cadence JedAI — Centralized data lake feeding all Cadence AI agents with cross-run memory
Cadence Verisium — Big-data + AI across multiple simulation runs; root-cause analysis agent
Synopsys AgentEngineer — Prototype at DAC 2025; built on Microsoft Discovery; L2→L5 autonomy roadmap; formal assertion generation
Siemens Fuse EDA AI Agent — Multi-domain agent across semiconductor, 3D IC, PCB; NVIDIA NIM + Nemotron models
Siemens Questa One Agentic Toolkit — Domain-scoped agents for RTL sign-off; multi-agent verification planning
Awesome-LLM4EDA growing Curated research hub for LLMs in EDA (SJTU)
Chip-Design-LLM-Zoo — Community hub of LLMs targeting chip design
EDAAgent — Autonomous EDA agent with tool-use memory for multi-step chip design tasks

Memory types used: Procedural (EDA scripts, Tcl, design rules), semantic (component/IP libraries), episodic (prior tapeout PPA runs), cross-run RL (Cadence Cerebrus learning across designs)

Pharmaceutical & Drug Discovery

Memory challenge: Wet lab runs cost $10k–$1M+ and are irreversible. Agents must retain structure-activity relationships (SAR) across thousands of assay runs, track hypothesis lineage, and distinguish informative negatives from successes. Memory must span years-long research timelines with privacy constraints around patient trial data.

Tool / Resource Stars Description
ChemCrow ~1.3k 18 expert chemistry tools + GPT-4 + LangChain; autonomously synthesized DEET; Nature Machine Intelligence 2024
ChemAgent growing ICLR 2025: self-updating Planning Memory + Execution Memory + Knowledge Memory; +46% on SciBench vs GPT-4 baseline
DrugAgent growing Multi-agent: LLM Planner + LLM Instructor; biomedical data retrieval, molecular generation, property prediction, 3D protein-ligand generation
BioAgents growing Multi-agent: literature analysis + data scientist agents; iterative scientific discovery loop
AlphaFold 3 ~15k Structure prediction; agents use predicted structures as episodic memory priors
ProteinGym ~700 ~2.7M missense variants across 217 DMS assays; standard benchmark for mutation effect predictors
Recursion OS — Automated high-throughput phenomic imaging + DL; 50B+ images; merged with Exscientia (2024); 18-month target-to-IND vs 42mo industry avg
Chemistry42 (Insilico Medicine) — Generative AI + DL + RL for autonomous molecular design; IPF drug candidate in Phase II clinical trials
Schrödinger FEP+ — Physics-based molecular simulation + ML; zasocitinib (TAK-279) advanced to Phase III
AstraZeneca ChatInvent — Multi-agent architecture with GUI; evolved from single-agent proof-of-concept; integrated into discovery pipeline
Awesome-BioAgent-Papers growing Curated list of LLM agent papers in biology/medicine
Awesome-LLM-Agents-Scientific-Discovery growing LLM agents in biomedical research, genomics, medical imaging

Memory types used: Semantic (molecular property knowledge), episodic (past synthesis/assay runs), procedural (synthesis route protocols), associative (SAR relationship graphs)

Key papers: AI Agents in Drug Discovery (2025 survey) · ChemAgent ICLR 2025 · Democratising drug discovery through agentic AI

Healthcare & Clinical AI

Memory challenge: HIPAA/GDPR mandate data minimization, consent management, role-based access, and audit trails on every memory read/write. Patient memory must span decades of EHR data with temporal coherence (drug A prescribed before condition B). Memory must distinguish verified clinical facts from clinician observations. Memory frameworks like mem0/Letta require custom compliance wrappers for healthcare production deployment.

Tool / Resource Description
Epic EHR + Azure OpenAI HIPAA-compliant generative AI via Microsoft Azure OpenAI; integrates longitudinal patient context into clinical workflows; deployed across 350M+ patient records
Stanford HAI Longitudinal EHR Research initiative for training AI on long-term health patterns (chronic disease, cancer treatment)
NYUTron Hospital LLM trained on EHR data; longitudinal patient memory (Nature 2023)
Intuitive Surgical Case Insights (da Vinci 5) Post-surgical AI: tracks operative time per step, movement smoothness; longitudinal surgical performance profile; 25% reduction in operative time
NVIDIA Autonomous Surgery Research VLM trained on surgical video + da Vinci integration; zero-shot surgical task execution via imitation learning (Johns Hopkins / Stanford)
Microsoft Azure Health Data Services HIPAA-compliant memory store for clinical AI agents
AWS HealthLake FHIR-native memory for clinical agents with semantic search
Ambience Healthcare AI ambient documentation — episodic memory of clinical encounters
Abridge AI for clinical notes with session memory and longitudinal context
PathAI Pathology AI with memory of prior case patterns for diagnostic agents

Memory types used: Longitudinal episodic (encounter history across decades), semantic (ICD-10, SNOMED, drug interactions), temporal (lab value trends, disease progression), working memory (current encounter context)

Key papers: Comprehensive Survey of AI Agents in Healthcare · Foundational Architecture for AI Agents in Healthcare

Finance & Trading

Memory challenge: Markets are adversarial — memory of past regimes can mislead if conditions change. Agents must distinguish regime memory (bull/bear) from event memory (earnings) from behavioral memory (client risk tolerance). Fraud detection requires continuously updating behavioral baselines without concept drift. MiFID II and SEC require auditable memory access logs.

Tool / Resource Stars Description
FinMem growing Layered memory (short/medium/long-term cognitive spans) mirroring human trader cognition; ICLR Workshop + IEEE 2025
FinAgent growing Multimodal foundation agent; layered memorization + technical indicators; KDD 2024
HedgeAgents — Balance-aware multi-agent financial trading; 2025
FinGPT ~15k Open-source financial LLM with news and market data memory
TradingGPT growing GPT-based trading agent with multi-layer memory and diverse roles
AI4Finance-Foundation — Org with 15+ financial agent + memory repos
OpenBB ~35k Open-source financial terminal — foundation for agents with financial data memory
Sardine — Behavioral biometrics + transaction graph memory for real-time fraud, credit, compliance
IBM AI Fraud Detection — Behavioral signature memory: keystroke cadence, mouse trajectories, touchscreen pressure
Visa Agentic AI — Real-time transaction fraud; behavioral memory across millions of accounts
Bloomberg GPT — Finance domain LLM; agents use semantic memory over Bloomberg terminal data

Memory types used: Layered temporal (short/medium/long-term price memory), episodic (trade outcomes), semantic (financial knowledge), behavioral biometrics (fraud), client preference (wealth management)

Key papers: FinMem: Performance-Enhanced LLM Trading Agent · FinAgent: Multimodal Foundation Agent

Legal & Compliance

Memory challenge: Every retrieved memory must link back to authoritative source (case, statute, regulation) — hallucinated precedents have caused real attorneys to be sanctioned. Memory must handle temporal validity (an overruled precedent is dead memory). Jurisdiction-scoping is critical. One 2024 study found specialized legal LLMs hallucinate 17–33% of the time even when marketed as "hallucination-free."

Tool / Resource Stars Description
Harvey AI — 700+ clients, 42% of AmLaw 100; "Vault" knowledge base for firm-specific memory; $8B valuation (Oct 2025); LexisNexis partnership June 2025
Thomson Reuters CoCounsel — Acquired from Casetext ($650M); semantic search over TR's authoritative legal database
LexisNexis Lexis+ AI — Legal research with semantic memory over 4M+ case documents
OLAW (Harvard LIL) growing Open Legal AI Workbench; RAG for legal AI research; CourtListener API; Harvard Library Innovation Lab
LegalBench ~800 162 legal reasoning tasks; agents need procedural + semantic memory
LLM-and-Law growing Papers: LawBench, LegalAgentBench, and more
LawAgent growing Curated list of law and legal AI agent resources
GC.ai — AI platform for in-house legal teams with document memory
EvenUp — Demand letter automation with memory of case facts and medical records
Ironclad AI — Contract management with clause memory and negotiation history
Relativity aiR — eDiscovery with document memory for review agents

Memory types used: Semantic (statute/case databases), episodic (matter history), temporal (precedent validity windows — knowing when a case was overruled), procedural (jurisdiction-specific playbooks)

Manufacturing & Industrial IoT

Memory challenge: OT (operational technology) networks are often air-gapped from IT — cloud-based memory is unavailable on the factory floor. Local/edge memory is mandatory. Safety-critical environments mean a wrong action from stale memory can cause injury or catastrophic failure. Multi-shift operations require temporal memory handoffs across crews. Gartner named agentic AI the #1 technology trend for 2025; Deloitte projects 50% of GenAI enterprises will deploy autonomous industrial agents by 2027.

Tool / Resource Description
XMPro APEX Policy-constrained execution; shared memory across agent teams; coordinates specialized agents with structured memory and planning frameworks
XMPro MAGS Multi-Agent Generative Systems; self-organizing teams; real-time industrial awareness; 250%+ documented ROI; $10M/yr savings at potash mining customer
NVIDIA Omniverse + Isaac Simulation platform for manufacturing agents with persistent environment memory
PTC ThingWorx + AI Industrial IoT platform with time-series memory for production agents
OSIsoft PI (AVEVA) Historian-based memory for industrial process agents
Rockwell Automation FactoryTalk AI Factory operations agent with production history memory
Siemens Industrial Copilot Generative AI for automation with persistent machine context
GE Predix (Vernova) Asset performance management with long-term equipment memory

Memory types used: Temporal (sensor time-series, equipment lifecycle), episodic (failure events, maintenance records), semantic (equipment specs, failure modes), procedural (SOPs)

Scientific Research & Labs

Memory challenge: Scientific memory must support causal chains spanning months or years. Reproducibility mandates that the exact memory state at the time of discovery be recoverable. Self-driving labs need memory bridging robotic hardware state, experimental parameters, and statistical models simultaneously. Key research finding: "Current memory architectures are ill-equipped to store, retrieve, and reason across diverse data types seamlessly." — Agentic Science Survey 2025

Tool / Resource Stars Description
AgentLaboratory growing End-to-end autonomous research: literature review → experiment → report; arXiv 2501.04227; 84% cost reduction vs prior methods
AgentRxiv — Agents upload, retrieve, and build on each other's research; shared cumulative memory; improved MATH-500 from 70.2% → 79.8% via collaboration
Awesome-Self-Driving-Labs growing Community-curated: hardware automation + AI closed-loop lab workflows
Awesome-AI-for-Science growing Physics, chemistry, biology, materials — multi-domain science agent resources
ChemCrow ~1.3k Chemistry lab agent with memory of reactions, reagents, synthesis routes
Emerald Cloud Lab — Fully automated research lab with programmable experiment memory
Benchling — Life science R&D platform with experiment and protocol memory
MLflow ~20k ML experiment tracking — episodic memory for model training agents
Weights & Biases — Experiment tracking with rich run memory for AI/ML research agents
Elicit — AI research assistant with memory of literature and hypotheses
ORNL HPC Experiment Agents — AI agents for autonomous experiments at Oak Ridge National Lab (ACM SC '25)

Memory types used: Episodic (experiment runs), semantic (domain literature), procedural (protocols, synthetic routes), causal (hypothesis→experiment→result chains)

Key papers: Agentic AI for Scientific Discovery Survey · AgentRxiv: Collaborative Autonomous Research

Autonomous Vehicles & Robotics

Memory challenge: Spatial memory must operate at millisecond latency. Episodic memory must support counterfactual reasoning ("what if I had turned left?"). Safety-critical applications mean memory failures can be life-threatening. Long-horizon navigation requires persistent topological maps valid across sessions, seasons, and environmental changes. Waymo's hybrid architecture pairs "fast-thinking" sensor fusion (breaks scene into objects) with "slow-thinking" VLM (holistic scene understanding) — mirroring dual-process cognitive theory.

Tool / Resource Stars Description
RoboMemory — Brain-inspired: Spatial + Temporal + Episodic + Semantic under parallelized architecture; lifelong learning in physical embodied systems
ELLA (Embodied Lifelong Learning) — Name-centric semantic memory (hierarchical scene graphs + KGs) + spatiotemporal episodic memory; multi-modal experience capture
Hydra (MIT SPARK) ~700 3D scene graph SLAM for spatial memory in robots; real-time hierarchical map maintenance
SayPlan — Scene graph-based semantic memory for robotic long-horizon task planning
VoxPoser — LLM + spatial value maps as robot working memory for manipulation
RT-2 (Google DeepMind) — Robotics Transformer with implicit semantic memory from internet-scale pretraining
Waymo EMMA — Built on Gemini; processes raw camera + text; chain-of-thought planning; +6.7% end-to-end planning
Waymo World Model — Built on Genie 3 (Feb 2026); generative world model for hyper-realistic simulation memory
Tesla FSD — RNN ensemble predicting 5-second trajectory horizons; camera-only spatial memory
Awesome-Embodied-Robotics-and-Agent growing Curated LLM-powered embodied AI research
Awesome-LLM4AD growing LLM/VLM/VLA/World Model for autonomous driving (SJTU)
Awesome-World-Model growing World models for autonomous driving and robotics

Memory types used: Spatial (3D scene graphs, HD maps), episodic (trajectory history), procedural (motor skills), temporal (world model predictions)

Key papers: RoboMemory · ELLA · Waymo EMMA

Education & Tutoring

Memory challenge: Memory must track learning trajectory across months/years, preserve productive struggle history (knowing where a student got stuck is as valuable as knowing they got an answer wrong), and adapt to changing proficiency without catastrophic forgetting. FERPA and COPPA for minors constrain persistence. Memory serves two principals — student and teacher — with different access scopes.

Tool / Resource Description
Khanmigo (Khan Academy) Chat history → interest identification → personalized teaching; "Interests" memory feature (2025); hundreds of thousands of active users
Carnegie Learning MATHia Real-time performance analysis; adjusts difficulty/pacing; trained on 1.2B math problems from 5.5M students over 25 years — one of the largest longitudinal behavioral memory datasets in any domain
Carnegie Learning LiveHint AI LLM-based math tutor for middle/high school built on the 25yr behavioral memory dataset
Duolingo Max Roleplay and explanation features with user proficiency memory
Synthesis Tutor Problem-solving tutor with student challenge history
mem0 + Education Tutorial: Personalized tutoring agent using mem0 for student memory

Memory types used: Longitudinal episodic (learning history), semantic (curriculum knowledge), procedural (pedagogical strategies), behavioral (engagement and struggle patterns)

Key paper: AI-Powered Educational Agents: 82-study systematic review (MDPI, Jan 2023 – Feb 2025)

Space Research & Exploration

Memory challenge: Space missions have ultra-high-latency communication (up to 24 minutes one-way to Mars). Autonomous agents must carry all operational memory onboard — they cannot ask ground control in real time. Every byte of memory must count.

Tool / Resource Description
NASA JPL OPEN-SOURCE ROVER Open platform for building rovers with programmable memory modules
NASA Ames Planner/Scheduler (Europa) Autonomous planning with mission episodic memory — used on Curiosity and Perseverance
CODEX (JPL) Onboard AI executive with persistent state memory for deep space
ESA INTEGRAL Memory Agent Autonomous fault detection with long-term behavioral memory
AstroLLaMA Domain-adapted LLM for astronomy; agents on top use semantic memory over arXiv astro papers
Astropy Core astronomy Python library — foundation for science agents with observational memory
LSST/Rubin Observatory AI Vera Rubin's alert pipeline: episodic memory of 10M+ nightly transient events for autonomous follow-up agents
ExoplanetArchive + RAG NASA Exoplanet Archive; research agents use it as semantic memory for planetary science
OpenSpace Interactive data visualization of the universe — spatial memory layer for space exploration agents
Space-LLaVA Multimodal space agent with satellite image memory

Memory types used: Episodic (mission log, telemetry history), semantic (astronomical catalogs), procedural (fault-recovery playbooks), spatial (3D star maps and orbital mechanics)

Smart Agriculture & Livestock

Memory challenge: AI systems monitoring animals and crops must track individual animals over their lifetime (years), seasonal patterns, behavioral deviations, and genetic histories — at farm scale across thousands of animals.

Tool / Resource Description
Connecterra Ida (Cow AI) The "AI cow collar" — accelerometer + ML with per-cow episodic memory of rumination, walking, lying, eating patterns; detects illness days before symptoms show clinically
CattleEye Computer vision livestock monitoring with individual animal identity memory
Cainthus (acquired by Ever.Ag) Dairy cow facial recognition + behavior memory for 24/7 herd monitoring
SmaXtec Bolus sensors in cattle stomachs — continuous rumination + temperature memory per animal
Moocall Calving sensor with temporal behavioral memory to predict birth within 1 hour
Halter (Smart Cattle Collars) GPS + virtual fencing collar with spatial and behavioral memory per animal, NZ-based
John Deere See & Spray Precision agriculture with semantic memory of field weed maps
Climate Corporation (Bayer) Digital farming with seasonal yield memory and predictive field agents
FarmBot Open-source precision agriculture robot with crop growth memory
Arable Mark Field sensors with long-term microclimate and crop-stage memory for farm agents
Taranis Aerial scouting AI with field-level pest and disease episodic memory

Memory types used: Episodic (individual animal behavioral history), temporal (seasonal patterns), semantic (breed and disease databases), spatial (field and pasture maps)

Climate Science & Environmental Monitoring

Memory challenge: Climate agents operate over decades of data — extreme events, emissions trajectories, ocean temperatures, ice core records — requiring temporal memory that spans centuries.

Tool / Resource Description
ClimaX Microsoft's foundation model for weather and climate with temporal atmospheric memory
Aurora (Microsoft) AI weather model trained on 1M+ hours of data; agents use atmospheric state as working memory
GraphCast (DeepMind) 10-day weather forecasting; episodic memory of atmospheric states at 6-hour intervals
Pangeo Community platform for big ocean/climate data — semantic memory layer for climate agents
Earth System Grid Federation Archive of climate simulation outputs — long-term climate memory at petabyte scale
NASA Earthdata Satellite + sensor archive for environmental agents — decades of episodic Earth observations
ClimateGPT LLM for climate science with semantic memory over IPCC reports and scientific literature
WildfireGPT Wildfire analysis agent with temporal memory of fire history and climate data
Open Climate Fix ML for clean energy — agents with solar irradiance and grid memory

Memory types used: Temporal (climate time-series spanning decades), semantic (climate science ontologies), episodic (extreme event records), spatial (geospatial grids)

Defense & Intelligence

Memory challenge: Defense agents operate in adversarial environments where memory itself can be a target (adversarial poisoning, deception attacks). Memory must be auditable for chain-of-command accountability. DARPA's L2M program explicitly targets catastrophic forgetting — a robot deployed in year 1 must still perform year-1 tasks in year 3 while having learned new ones. Memory in this domain must be adversarially robust.

Program / Tool Description
DARPA L2M (Lifelong Learning Machines) Develops systems that learn continuously during execution, become increasingly expert, apply prior skills to new tasks without forgetting; bio-inspired memory mechanisms
DARPA GARD Guaranteeing AI Robustness against Deception; addresses memory poisoning and deception attacks; transitioned to DoD CDAO
DARPA REMA Rapid Experimental Missionized Autonomy; $13.8M FY2025; autonomous operation subsystems for military drones
DARPA SABER Operational AI security exercises; evaluates AI-enabled autonomous ground and aerial systems in battlefield settings
DARPA AIxCC AI agents autonomously finding/fixing open-source CVEs; demonstrated faster-than-human performance on real vulnerabilities
DARPA INSPIRE Investigates Long-Term Synaptic Plasticity (LTSP); USC-funded; translates biological memory formation into AI systems
Palantir Gotham + AIP AI platform for defense with persistent entity and event memory across intelligence streams
Anduril Lattice Autonomous systems OS with shared battlefield memory across sensor networks
Lockheed Martin (DARPA contract) DARPA contract for AI/ML tool development; July 2024

Memory types used: Lifelong/continual (L2M program), procedural (mission playbooks), episodic (operational history), adversarially-robust semantic (GARD program)

Energy & Utilities

Memory challenge: Power grids operate 24/7 with decades of equipment, outage histories, and load patterns. Memory is critical for predictive maintenance, demand forecasting, and autonomous grid balancing.

Tool / Resource Description
GridDynamics + AI Grid management agents with long-term outage and demand memory
Uplight Utility customer engagement AI with behavioral energy-use memory
AutoGrid (Enel) Virtual power plant with distributed energy resource (DER) memory
Open Climate Fix Solar Solar irradiance forecasting agents with location-specific generation history
ENERTIV Building energy agents with HVAC behavioral and anomaly memory
Sievert (Arcadia) Energy data platform — semantic memory over utility rates and usage

Cross-Vertical Summary

Vertical Primary Memory Type Key Constraint Dominant Architecture
Chip / EDA Procedural + cross-run RL Decades of proprietary tapeout data Domain-adapted LLM + KV store + cross-run learning DB
Pharma SAR episodic + causal Irreversibility + wet lab cost KG + molecular database + hypothesis chain
Healthcare Longitudinal episodic HIPAA/GDPR compliance HIPAA-compliant vector store + EHR-integrated retrieval
Finance Layered temporal Regime shifts + regulatory audit Layered memory (short/medium/long-term) + behavioral biometrics
Legal Semantic + temporal validity Citation traceability + hallucination risk RAG over authoritative corpus + precedent validity tracking
Manufacturing Temporal sensor + procedural Edge deployment (no cloud) + safety Local time-series DB + equipment knowledge graph
Science / Lab Causal chain + episodic Reproducibility + long-horizon reasoning KG + protocol memory + cumulative shared memory
AV / Robotics Spatial + world model Real-time latency + safety 3D scene graph + world model + episodic trajectory buffer
Education Behavioral longitudinal FERPA/COPPA + dual-principal access Student mastery model + longitudinal interaction history
Defense Lifelong continual Adversarial robustness + catastrophic forgetting Bio-inspired continual learning + adversarially-robust encoding
Space Episodic + onboard-only Communication latency + memory budget Onboard planner + mission episodic log + astronomical catalogs
Agriculture Episodic per-entity Lifetime animal/crop tracking at farm scale Sensor time-series + spatial map + individual identity memory
Climate Temporal (century-scale) Data volume + temporal span Petabyte climate archives + geospatial grids
Energy Temporal sensor Real-time grid balancing Time-series DB + demand forecasting memory

Cross-Vertical Research Collections

📖 Research Papers

Foundational and cutting-edge research on agent memory systems.

Paper Venue Links Key Contribution
MemGPT: Towards LLMs as Operating Systems NeurIPS 2023 arXiv OS-inspired virtual context management
A Survey on the Memory Mechanism of LLM-based Agents 2024 arXiv Systematic review of memory module design
LongMemEval: Benchmarking Chat Assistants on Long-Term Memory ICLR 2025 arXiv · GitHub 500-question evaluation benchmark
Memory in the Age of AI Agents: A Survey 2024 arXiv · GitHub Taxonomy: token-level, parametric, latent
Zep: Temporal Knowledge Graph Architecture 2025 arXiv Temporal KG with validity windows
A-MEM: Agentic Memory for LLM Agents NeurIPS 2025 arXiv · GitHub Zettelkasten-inspired dynamic memory
Hindsight is 20/20 2025 arXiv · GitHub 4-network biomimetic, 91.4% LongMemEval
MemOS: OS for Memory-Augmented LLMs 2025 arXiv OS metaphor for LLM memory management
MemoryAgentBench ICLR 2026 GitHub Incremental multi-turn interaction benchmark
RoboMemory: Brain-inspired Memory for Robots 2025 arXiv Spatial + Temporal + Episodic for physical robots
Ella: Embodied Social Agents with Lifelong Memory 2025 arXiv Lifelong memory for social embodied agents
Rethinking Memory Mechanisms of Foundation Agents 2026 arXiv Survey of second-generation memory trends

📏 Benchmarks & Evaluation

Benchmark GitHub Metric Key Finding
LongMemEval (ICLR 2025) GitHub 500 Q, 5 categories GPT-4o drops 30% on long-term recall
MemoryAgentBench (ICLR 2026) GitHub Incremental multi-turn Tests incremental fact acquisition
MemBench (ACL 2025) ACL Anthology Factual + reflective Tests both storage and reasoning
MemoryBench (Supermemory) GitHub Cross-provider comparison Open framework for comparing systems
LongBench GitHub Long-context tasks General long-context evaluation

📚 Awesome Paper Collections

📖 Learning Resources

Tutorials & Guides

Courses & Videos

Key Concepts

Term Definition
Episodic Memory Records of past events and interactions
Semantic Memory General facts and knowledge
Procedural Memory How to perform tasks (skills, workflows)
Working Memory Active context window
Archival Memory Long-term storage requiring search
Temporal KG Knowledge graph where facts have validity time windows
RAG Retrieval-Augmented Generation — fetching relevant memories
MCP Model Context Protocol — standard for memory server plugins

🤝 Contributing

This list is built and maintained by the community. Every contribution helps.

Adding a new entry:

  1. Fork the repo
  2. Add your entry under the appropriate section
  3. Follow the format: [Name](URL) — Brief description (one line max)
  4. Ensure the project is open-source OR has free public documentation
  5. The project must be actively maintained (last commit within 12 months)
  6. Submit a PR with the title Add [ProjectName] to [Section]

Criteria for inclusion:

  • Solves a real memory problem for AI agents
  • Has working documentation or examples
  • Not abandoned/archived (unless historically significant)
  • No pure self-promotion — must provide value to others

Improving existing entries:

  • Fix broken links
  • Update star counts
  • Add missing code examples
  • Fix descriptions

See CONTRIBUTING.md for full guidelines.

⭐ Star History

Star History Chart

If this list saved you time, please consider starring it ⭐

Maintained by @aviskaar and contributors

CC0

About

No description, website, or topics provided.

Resources

Readme
CC0-1.0 license

Contributing

Contributing
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

2 forks
Report repository

Releases

Packages

Contributors