EverOS: Open-Source Long-Term Memory Operating System for Self-Evolving AI Agents

EverOS is an open-source long-term memory operating system for AI agents developed by EverMind, the AI research lab backed by Shanda Group. In an era where most AI agents operate with short-term, session-bound memory, EverOS introduces a persistent, self-organizing memory infrastructure that lets agents remember, reason, and evolve across sessions indefinitely.

The project has garnered over 4,200 GitHub stars and is backed by multiple peer-reviewed papers accepted at ACL 2026. Its monorepo architecture unifies four core components: EverCore (the self-organizing memory OS), HyperMem (the hypergraph memory engine), EverMemBench (a three-layer memory evaluation framework), and EvoAgentBench (an agent self-evolution benchmark).

graph TD
    A[Agent/LLM] --> B[EverCore]
    B --> C[HyperMem Hypergraph]
    B --> D[mRAG Multimodal Retriever]
    C --> E[Topic Hyperedges]
    C --> F[Event Hyperedges]
    C --> G[Fact Hyperedges]
    D --> H[Dense Vectors]
    D --> I[Sparse Keywords]
    D --> J[Multimodal Signals]
    B --> K[Evolved Skills]
    K --> A

What makes EverOS truly groundbreaking is its self-evolving capability. Agents can automatically distill skills and patterns from their task execution history, leading to a measured 234.8% relative improvement in complex task success rates over the baseline. This is not merely a caching layer – it is an active memory that grows smarter the more it is used.

What Is EverOS?

EverOS is a long-term memory operating system designed to sit between AI agents and their underlying LLM backends. It provides a persistent memory layer that automatically extracts, structures, retrieves, and evolves knowledge across agent sessions. Unlike simple vector stores or conversation history buffers, EverOS organizes memories into a self-organizing hypergraph where relationships between facts, events, and topics are explicitly modeled and continuously refined.

The system is model-agnostic and works across multiple LLM providers including OpenAI, Anthropic, and open-source models. This makes it suitable for everything from single-agent coding assistants to large-scale multi-agent orchestration platforms.

How Does Agent Memory Work in EverOS?

EverOS implements a three-tier memory architecture inspired by biological imprinting – the process by which living organisms form lasting memories from brief experiences.

EverCore is the foundational layer. It extracts, structures, and retrieves long-term knowledge using a self-organizing approach. When an agent completes a task, EverCore analyzes the interaction, identifies salient facts and patterns, and encodes them into the memory store. On subsequent interactions, it retrieves relevant memories to inform the agent’s reasoning.

HyperMem provides the storage engine. Built on a hypergraph data structure, it captures high-order associations that simple graphs cannot represent. A hyperedge can connect multiple nodes simultaneously, modeling complex relationships like “these five facts together explain concept X.” HyperMem has been accepted at ACL 2026 and achieved 92.73% accuracy on the LoCoMo long-term conversation benchmark.

mRAG (Multimodal RAG) is the retrieval layer. It fuses three retrieval modalities:

This hybrid approach ensures that memory retrieval is both semantically rich and factually precise, outperforming single-modality RAG systems in the project’s published benchmarks.

What Benchmarks Does EverOS Use?

EverOS ships with two built-in evaluation frameworks to measure memory and evolution quality.

EverMemBench evaluates memory quality across three layers:

EvoAgentBench measures agent self-evolution, tracking how agents improve their performance over time on longitudinal task sequences. In published results, agents using EverOS showed a 234.8% relative improvement in complex task success rates over 100+ task iterations.

How Does Hypergraph Memory Compare to Traditional Approaches?

Traditional RAG systems use vector databases that store flat embeddings. They excel at finding “similar” content but struggle with multi-hop reasoning and relationship modeling. Knowledge graphs improve on this by modeling entities and relationships explicitly, but standard property graphs cannot represent higher-order relationships that involve more than two entities at once.

Hypergraph memory addresses this gap:

graph LR
    subgraph "Vector DB"
        A1[(Embedding 1)]
        A2[(Embedding 2)]
        A3[(Embedding 3)]
    end
    subgraph "Property Graph"
        B1[Entity A] -- relates --> B2[Entity B]
    end
    subgraph "Hypergraph HyperMem"
        C1[Fact 1]
        C2[Fact 2]
        C3[Fact 3]
        C4{HyperEdge X} --- C1
        C4 --- C2
        C4 --- C3
    end

In a hypergraph, a single hyperedge connects an arbitrary number of nodes. This means a memory like “the user prefers Python, has experience with FastAPI, worked on project P, and reported issue #42” can be stored as a single hypergraph unit rather than fragmented across multiple pairwise relationships. HyperMem’s hyperedges operate at three hierarchical levels: topic, event, and fact, enabling multi-granularity retrieval.

The EverOS Ecosystem

Beyond the core components, EverOS supports an expanding ecosystem of integrations and applications:

• Claude Code Plugin – Persistent memory for Claude Code sessions
• OpenClaw Agent – A 24/7 agent with continuous learning capability
• Live2D Characters – Memory-powered anime characters for interactive experiences
• Multi-agent orchestration via the Golutra platform
• Earth Online – A memory-aware productivity game

EverMind also hosts the Memory Genesis Competition 2026, an open competition with tracks for agent developers, platform plugin builders, and OS infrastructure contributors, with prizes and recognition for the best memory-enabled applications.

Getting Started with EverOS

EverOS is designed for easy local deployment:

git clone https://github.com/EverMind-AI/EverOS.git
cd EverOS
docker compose up -d
uv sync
# Configure your .env with API keys
uv run python src/run.py

The server launches at http://localhost:1995 with a REST API and web dashboard. You can integrate any LLM-powered agent by making API calls to the EverOS memory endpoints. The project’s documentation site provides detailed integration guides and API references.

FAQ

What is EverOS? EverOS is an open-source long-term memory operating system for AI agents, developed by EverMind. It enables agents to persist, structure, and self-evolve memory across sessions, supporting multiple LLM backends and platforms.

How does agent memory work in EverOS? EverOS uses a biological-imprinting-inspired architecture with three layers: EverCore for self-organizing memory, HyperMem for hypergraph-based hierarchical storage, and mRAG for multimodal retrieval augmented generation that fuses dense vectors, sparse keywords, and multimodal signals.

What is HyperMem? HyperMem is a hypergraph-based hierarchical memory architecture accepted at ACL 2026. It captures high-order associations via hyperedges across topic, event, and fact layers, achieving 92.73% accuracy on the LoCoMo long-term conversation benchmark.

What benchmarks does EverOS support? EverOS includes EverMemBench for three-layer memory quality evaluation (factual recall, applied reasoning, personalized generalization) and EvoAgentBench for measuring agent self-evolution over longitudinal tasks.

How do I get started with EverOS? Clone the repo from github.com/EverMind-AI/EverOS, run docker compose up -d, sync dependencies with uv sync, configure your .env file with API keys, and launch with uv run python src/run.py. The server starts at http://localhost:1995.

Further Reading

• EverOS GitHub Repository
• EverMemOS: A Self-Organizing Memory OS – arXiv 2601.02163
• EverMind Official Site
• EverOS Documentation