Evermemos

Table of Contents

• Project Overview
• Use Cases
• Quick Start
• Architecture Methods
• Benchmarks
• Evaluation
• Citations
• Stay Tuned
• Contributing

Project Overview

EverOS is a unified home for building, evaluating, and applying long-term memory in self-evolving agents. The repository is organized around three essential parts:

Part	What it gives you	Start here
Architecture methods	Memory systems and algorithms you can run, extend, or compare.	methods/
Benchmarks	Open evaluation suites for memory quality and agent self-evolution.	benchmarks/
Use cases	Apps, demos, and integrations showing how memory changes real agent workflows.	use-cases/

At the center of EverOS is EverCore, a long-term memory operating system for agents. If you are new to the project, scan the use cases first to see what memory enables, then follow the Quick Start to run EverCore locally. The architecture and benchmark sections below give you the deeper reference material when you are ready to compare systems or reproduce results.

EverOS/
├── benchmarks/                
│   ├── EverMemBench/    
│   └── EvoAgentBench/         
├── methods/                   
│   ├── EverCore/              
│   └── HyperMem/              
└── use-cases/                 
    ├── claude-code-plugin/    
    ├── game-of-throne-demo/   
    ├── openher/            
    ├── ...
    └── ...

Use Cases

Use cases show what persistent memory makes possible in real products and workflows. Some examples are packaged in this repository; others point to external demos or integrations you can study and adapt.

Earth Online Memory Game Earth Online is a memory-aware productivity game that turns everyday planning into a living quest log.	Multi-Agent Orchestration Platform Golutra presents a multi-agent workforce for engineering teams, extending the IDE model from a single assistant to coordinated agents.
Mobi Companion An iOS app where users create, nurture, and live with a personalized AI companion called Mobi.	AI Wearable with Memory A context-native AI wearable that listens to everyday life and converts conversations into memory.
OpenClaw Agent Memory A 24/7 agent workflow with continuous learning memory across sessions. Agent Memory · Plugin	Live2D Character with Memory Add long-term memory to a real-time Live2D character, powered by TEN Framework. Code
Computer-Use with Memory Run screenshot-based analysis with computer-use and store the results in memory. Live Demo	Game of Thrones Memories A demonstration of AI memory infrastructure through an interactive Q&A experience with A Game of Thrones. Code
Claude Code Plugin Persistent memory for Claude Code. Automatically saves and recalls context from past coding sessions. Code	Memory Graph Visualization Explore stored entities and relationships in a graph interface. Frontend demo; backend integration is in progress. Live Demo

Quick Start

Choose the path that matches your goal:

git clone https://github.com/EverMind-AI/EverOS.git
cd EverOS

Goal	Component	Entry Point
Build agents with long-term memory	EverCore	methods/EverCore/
Explore the hypergraph memory architecture	HyperMem	methods/HyperMem/
Evaluate memory system quality	EverMemBench	benchmarks/EverMemBench/
Measure agent self-evolution	EvoAgentBench	benchmarks/EvoAgentBench/
Adapt an example app or integration	Use cases	use-cases/

Each component has its own installation guide, dependency configuration, and usage examples.

EverCore

The fastest way to run a memory system locally is to start with EverCore:

cd methods/EverCore

# Start Docker services
docker compose up -d

# Install dependencies
curl -LsSf https://astral.sh/uv/install.sh | sh
uv sync

# Configure API keys
cp env.template .env
# Edit .env and set:
#   - LLM_API_KEY (for memory extraction)
#   - VECTORIZE_API_KEY (for embedding/rerank)

# Start server
uv run python src/run.py

# Verify installation
curl http://localhost:1995/health
# Expected response: {"status": "healthy", ...}

Server runs at http://localhost:1995 · Full Setup Guide

Basic Usage

Store and retrieve memories with simple Python code:

import requests

API_BASE = "http://localhost:1995/api/v1"

# 1. Store a conversation memory
requests.post(f"{API_BASE}/memories", json={
    "message_id": "msg_001",
    "create_time": "2025-02-01T10:00:00+00:00",
    "sender": "user_001",
    "content": "I love playing soccer on weekends"
})

# 2. Search for relevant memories
response = requests.get(f"{API_BASE}/memories/search", json={
    "query": "What sports does the user like?",
    "user_id": "user_001",
    "memory_types": ["episodic_memory"],
    "retrieve_method": "hybrid"
})

result = response.json().get("result", {})
for memory_group in result.get("memories", []):
    print(f"Memory: {memory_group}")

More Examples · API Reference · Interactive Demos

Architecture Methods

These are the memory architectures currently included in EverOS. Use them as runnable systems, research references, or starting points for your own agent memory layer.

EverCore A self-organizing memory operating system inspired by biological imprinting. Extracts, structures, and retrieves long-term knowledge from conversations so agents can remember, understand, and continuously evolve. LoCoMo 93.05% · LongMemEval 83.00% Paper · Docs

HyperMem A hypergraph-based hierarchical memory architecture that captures high-order associations through hyperedges, with topic, event, and fact layers for coarse-to-fine conversation retrieval. LoCoMo 92.73% Paper · Docs

Benchmarks

These benchmarks provide shared standards for measuring memory quality and agent self-evolution across systems.

EverMemBench Three-layer memory quality evaluation: factual recall, applied reasoning, and personalized generalization. Paper · Dataset · Docs

EvoAgentBench Agent self-evolution evaluation through longitudinal growth curves, transfer efficiency, error avoidance, and skill-hit quality. Docs

Evaluation

Use the evaluation runner to reproduce EverCore results or compare another memory system against the same benchmark tasks.

Benchmark Results

Supported Benchmarks

• LoCoMo — Long-context memory benchmark with single/multi-hop reasoning
• LongMemEval — Multi-session conversation evaluation
• PersonaMem — Persona-based memory evaluation

Run Evaluations

cd methods/EverCore

# Install evaluation dependencies
uv sync --group evaluation

# Run smoke test (quick verification)
uv run python -m evaluation.cli --dataset locomo --system everos --smoke

# Run full evaluation
uv run python -m evaluation.cli --dataset locomo --system everos

# View results
cat evaluation/results/locomo-everos/report.txt

Full Evaluation Guide · Complete Results

Citations

If EverOS helps your research, please cite the relevant paper:

@article{hu2026evermemos,
  title   = {EverMemOS: A Self-Organizing Memory Operating System for Structured Long-Horizon Reasoning},
  author  = {Chuanrui Hu and Xingze Gao and Zuyi Zhou and Dannong Xu and Yi Bai and Xintong Li and Hui Zhang and Tong Li and Chong Zhang and Lidong Bing and Yafeng Deng},
  journal = {arXiv preprint arXiv:2601.02163},
  year    = {2026}
}

@article{yue2026hypermem,
  title   = {HyperMem: Hypergraph Memory for Long-Term Conversations},
  author  = {Juwei Yue and Chuanrui Hu and Jiawei Sheng and Zuyi Zhou and Wenyuan Zhang and Tingwen Liu and Li Guo and Yafeng Deng},
  journal = {arXiv preprint arXiv:2604.08256},
  year    = {2026}
}

@article{hu2026evaluating,
  title   = {Evaluating Long-Horizon Memory for Multi-Party Collaborative Dialogues},
  author  = {Chuanrui Hu and Tong Li and Xingze Gao and Hongda Chen and Yi Bai and Dannong Xu and Tianwei Lin and Xiaohong Li and Yunyun Han and Jian Pei and Yafeng Deng},
  journal = {arXiv preprint arXiv:2602.01313},
  year    = {2026}
}

Stay Tuned

Star the repo or join the community links above to follow new architecture methods, benchmark releases, and memory-enabled use cases.

Contributing

Contributions are welcome across the whole repository: architecture methods, benchmark coverage, use-case examples, documentation, and bug fixes. Browse Issues to find a good entry point, then open a PR when you are ready.

[!TIP]

Welcome all kinds of contributions 🎉

Help make EverOS better. Code, documentation, benchmark reports, use-case write-ups, and integration examples are all valuable. Share your projects on social media to inspire others.

Connect with one of the EverOS maintainers @elliotchen200 on 𝕏 or @cyfyifanchen on GitHub for project updates, discussions, and collaboration opportunities.

Code Contributors

Contribution Guidelines

Read the Contribution Guidelines for setup, pull request expectations, and use-case submission notes. For responsible disclosure, see the Security Policy.

License, Conduct, and Acknowledgments

Apache 2.0 • Code of Conduct • Acknowledgments