Meet EverOS: An Open Supply Markdown-First Agent Reminiscence Runtime With Hybrid BM25 + Vector Retrieval and Self-Evolving Abilities

EverMind has launched EverOS, an open-source reminiscence runtime for AI brokers. It ships beneath an Apache 2.0 license. It targets an issue agent builders hit early: giant language fashions are stateless. The dialog ends, and the context is gone.

EverOS proposes a special substrate. As a substitute of locking reminiscence inside a vector database, it writes reminiscence as plain Markdown recordsdata. These recordsdata turn out to be the supply of fact that brokers learn, edit, and search throughout classes.

TL;DR

• EverOS shops agent reminiscence as editable Markdown, listed by SQLite and LanceDB.
• Hybrid retrieval blends BM25, vector search, and scalar filtering in a single question.
• Circumstances distill into reusable Abilities, giving brokers procedural, self-evolving reminiscence.
• Benchmark scores are robust however EverMind-reported; confirm by yourself workload.
• It’s open supply beneath Apache 2.0, with cloud and self-hosted parity.

What’s EverOS?

EverOS is a Python library and a local-first reminiscence runtime. It runs as a server with a CLI and a FastAPI HTTP API, async-first all through. You drop it into an present agent loop quite than rebuilding your stack.

The design separates two reminiscence tracks. Consumer-side reminiscence holds Profiles, Episodes, Details, and Foresights. Agent-side reminiscence holds Circumstances and Abilities. Protecting them separate is uncommon; most libraries middle on chat historical past alone.

Each document lands as a .md file. You possibly can open, edit, grep, and Git-version it, or view it in Obsidian. EverAlgo, a separate stateless library, handles the extraction algorithms. EverOS orchestrates and persists the outcomes.

The endpoint stack is OpenAI-protocol suitable. It connects to OpenAI, OpenRouter, vLLM, Ollama, or DeepInfra by altering a base URL. That retains integration near a single configuration change.

The runtime is local-first by default. Knowledge by no means has to go away your atmosphere, and each layer is inspectable. A managed EverOS Cloud possibility exists for groups that desire to not self-host. Each share the identical SDK, retrieval engine, and reminiscence format.

The Structure — Markdown, SQLite, and LanceDB

EverOS makes use of a three-piece storage stack. Markdown is the supply of fact. SQLite manages state and queues. LanceDB manages vectors, BM25, and scalar filters.

That is intentionally lighter than a typical manufacturing reminiscence setup. There isn’t any required MongoDB, Elasticsearch, Milvus, Redis, or Kafka. For solo builders and small groups, that lowers operational price.

Retrieval is hybrid. A single LanceDB question combines BM25 key phrase matching, dense vector search, and scalar filtering. EverMind markets this multimodal retrieval path as mRAG.

A cascade index sync retains recordsdata and indexes aligned. Enhancing a .md file triggers a file-watcher that re-syncs the index. Reminiscence stays inspectable with out going stale.

Retrieval can be orthogonal throughout identifiers. You possibly can scope a search by user_id, agent_id, app_id, project_id, and session_id. That scoping is necessary in multi-agent and multi-user deployments the place information isolation is required.

How Reminiscence Self-Evolves — Circumstances Develop into Abilities

A particular characteristic is procedural reminiscence. EverOS data every accomplished agent process as a Case. Repeated profitable patterns are distilled offline into reusable Abilities.

That is the ‘self-evolving’ declare, acknowledged plainly. Abilities are shared throughout an agent workforce, with no guide curation and no hardcoding. The objective is brokers that enhance with use as a substitute of restarting every session.

Model 1.1.0 added extra lifecycle equipment. It launched Data APIs for source-backed Markdown pages with taxonomy and subject search. It additionally added Reflection, an offline course of that merges episode clusters and refines profiles and abilities between classes.

The reminiscence mannequin is easy. Episodic reminiscence solutions ‘what occurred.’ Profile reminiscence solutions ‘who is that this person.’ Procedural reminiscence solutions ‘how is that this process carried out.’

Benchmark

EverMind workforce stories 93.05% on LoCoMo, 83.00% on LongMemEval, and 93.04% on HaluMem. It additionally cites sub-500ms p95 retrieval latency. LoCoMo and LongMemEval measure long-term conversational reminiscence; HaluMem targets reminiscence hallucination. These numbers come from EverMind posts.

The desk beneath compares EverOS towards widespread alternate options on concrete design dimensions:

Use Circumstances, With Actual Examples

The library hyperlinks to working integrations. They present what persistent reminiscence permits in actual merchandise.

Hive Orchestrator is a browser-native hive-mind for CLI coding brokers. Claude Code, Codex, Gemini, and OpenCode collaborate as actual PTY processes by way of a shared workforce protocol.

Reunite makes use of semantic reminiscence for public-value search. Dad and mom describe what they bear in mind, kids describe what they recall, and the system surfaces connections.

Different examples span healthcare and {hardware}. They embody an Alzheimer’s reminiscence assistant and an AI wearable. The wearable listens to on a regular basis life and converts it into reminiscence. A research buddy with self-evolving reminiscence can be among the many examples. The broader ecosystem provides a Claude Code plugin and an MCP-based reminiscence layer for coding assistants.

A 5-Minute Code Walkthrough

Set up makes use of normal Python tooling. EverOS requires Python 3.12 or newer. The native demo wants no API keys.

# Requires Python 3.12+
uv pip set up everos        # or: pip set up everos
everos demo                  # native instructional visualizer, no keys
everos init                  # paste OpenRouter + DeepInfra keys into .env
everos server begin          # begins the FastAPI server
curl http://127.0.0.1:8000/well being   # -> {"standing":"okay"}

Including and looking out reminiscence are plain HTTP calls. The instance beneath shops a reality, forces extraction, then retrieves it.

# 1) Add a brief dialog
curl -X POST http://127.0.0.1:8000/api/v1/reminiscence/add 
  -H 'Content material-Sort: software/json' 
  -d '{"session_id":"demo-001","app_id":"default","project_id":"default",
       "messages":[{"sender_id":"alice","role":"user","timestamp":1750000000000,
                    "content":"I love climbing in Yosemite every spring."}]}'

# 2) Flush to power extraction (native demo)
curl -X POST http://127.0.0.1:8000/api/v1/reminiscence/flush 
  -H 'Content material-Sort: software/json' 
  -d '{"session_id":"demo-001","app_id":"default","project_id":"default"}'

# 3) Search it again
curl -X POST http://127.0.0.1:8000/api/v1/reminiscence/search 
  -H 'Content material-Sort: software/json' 
  -d '{"user_id":"alice","app_id":"default","project_id":"default",
       "question":"The place do I wish to climb?","top_k":5}'

Multimodal ingestion is an optionally available additional. Putting in everos[multimodal] provides parsing for pictures, PDFs, and audio. Workplace paperwork moreover require LibreOffice, which converts recordsdata to PDF earlier than parsing.

Strive It: Interactive Reminiscence Demo

The embedded demo beneath simulates the EverOS loop in your browser. Add a snippet, watch it get extracted and tagged, then search it again by way of hybrid retrieval. It’s illustrative and doesn’t hook up with a reside server.

‘;return;}
el.innerHTML = res.map(operate(r,i){
var pct=Math.spherical(r.hybrid*100);
return ‘

‘;
}).be a part of(”);
}

// —- wire up —-
operate present(card){ doc.getElementById(‘lastCard’).innerHTML=mdMarkup(card); }

doc.getElementById(‘addBtn’).addEventListener(‘click on’,operate(){
var v=doc.getElementById(‘memInput’).worth.trim();
if(!v) return;
var btn=this; btn.disabled=true;
runPipeline(operate(){
var m=addMemory(v);
present(m); refreshCounts(); renderStore();
doc.getElementById(‘memInput’).worth=””;
btn.disabled=false;
});
});

doc.getElementById(‘seedAllBtn’).addEventListener(‘click on’,operate(){
var btn=this; btn.disabled=true;
seeds.forEach(operate(s){ if(!reminiscences.some(operate(m){return m.textual content===s;})) addMemory(s); });
refreshCounts(); renderStore();
runPipeline(operate(){ present(reminiscences[memories.length-1]); btn.disabled=false; });
});

doc.getElementById(‘searchBtn’).addEventListener(‘click on’,operate(){
var q=doc.getElementById(‘queryInput’).worth.trim();
if(!q) return; renderResults(q);
});
doc.getElementById(‘queryInput’).addEventListener(‘keydown’,operate(e){if(e.key===’Enter’)doc.getElementById(‘searchBtn’).click on();});

// chips
var sc=doc.getElementById(‘seedChips’);
seeds.forEach(operate(s){var c=doc.createElement(‘span’);c.className=”chip”;c.textContent=s;c.onclick=operate(){doc.getElementById(‘memInput’).worth=s;};sc.appendChild(c);});
var qc=doc.getElementById(‘queryChips’);
queries.forEach(operate(s){var c=doc.createElement(‘span’);c.className=”chip”;c.textContent=s;c.onclick=operate(){doc.getElementById(‘queryInput’).worth=s;doc.getElementById(‘searchBtn’).click on();};qc.appendChild(c);});

// tabs
doc.querySelectorAll(‘.tab’).forEach(operate(t){
t.addEventListener(‘click on’,operate(){
doc.querySelectorAll(‘.tab’).forEach(operate(x){x.classList.take away(‘lively’);});
doc.querySelectorAll(‘.view’).forEach(operate(x){x.classList.take away(‘lively’);});
t.classList.add(‘lively’);
doc.getElementById(‘view-‘+t.dataset.tab).classList.add(‘lively’);
if(t.dataset.tab===’retailer’) renderStore();
reportHeight();
});
});

renderStore(); refreshCounts();

// auto-resize for WordPress iframe embedding (part top + buffer)
operate reportHeight(){
var h=doc.getElementById(‘app’).offsetHeight+40;
if(window.father or mother){ window.father or mother.postMessage({everosDemoHeight:h},’*’); }
}
window.addEventListener(‘load’,reportHeight);
window.addEventListener(‘resize’,reportHeight);
var obs=new MutationObserver(reportHeight);
obs.observe(doc.getElementById(‘app’),{childList:true,subtree:true});
})();