Every AI conversation I had vanished the moment I closed the tab. Weeks of research, planning sessions, decision context — gone. I'd spend an hour explaining my project structure, my coding preferences, my infrastructure setup — and the next session started from zero. So I built a system that fixes that permanently.
Eidetic OS (formerly Atlas OS) is an open-source personal AI operating system that wraps Claude Cowork and Claude Code with persistent memory, hybrid RAG search, 160+ installable skills, scheduled automation pipelines, a full web dashboard, and pluggable backends for both LLMs and vector databases. It turns a stateless chatbot into something that remembers everything, learns from every interaction, and works autonomously while you sleep.
Why "Eidetic"? The word means having perfect, photographic memory recall — the ability to remember everything you've ever seen or experienced with total clarity. That's exactly what this system does for your AI. We renamed from Atlas OS to avoid namespace collisions with the Windows debloater project (20.8K GitHub stars) and Fluidstack's bare-metal infrastructure OS. The old name buried us in search results. "Eidetic" is unique, memorable, and communicates exactly what the system does: your AI never forgets.
GitHub: paulholland511/atlas-os | pip install eidetic-os
The Problem: AI Amnesia
If you've spent any time with Claude, ChatGPT, or any conversational AI, you've hit this wall. You build up context over a long session — your project architecture, your preferences, your ongoing decisions — and then the conversation ends. Next time, you start from scratch.
Some tools try to solve this with conversation history. But raw conversation logs are a terrible memory format. They're full of false starts, corrections, tangents, and redundancy. Searching through thousands of lines of dialogue to find that one architectural decision you made three weeks ago? Painful.
I wanted something different: a system where every conversation automatically becomes part of a searchable, structured knowledge base. Where the AI can instantly recall not just what we discussed, but the decisions we made and why. Where background processes keep the knowledge fresh, indexed, and connected.
That's what Eidetic OS does.
The Architecture
┌──────────────────────────────────────────────────────────┐
│ eidetic CLI │
│ init · doctor · search · embed · dashboard · skills │
├──────────┬──────────┬───────────┬────────────────────────┤
│ Vault │ RAG │ Skills │ LLM Backends │
│ Parser │ Engine │ 160+ │ LM Studio │
│ Git Sync│ SQLite │ Market- │ Ollama │
│ Session │ BM25+Vec│ place │ llama.cpp │
│ Capture │ RRF │ MCP │ OpenAI-compatible │
│ Locking │ Rerank │ Registry │ Auto-detect │
├──────────┼──────────┼───────────┼────────────────────────┤
│ Exten- │ Security │ Vector │ Dashboard │
│ sions │ AST Scan │ Backends │ Flask + D3.js │
│ Plug- │ Sandbox │ SQLite │ 7 Panels │
│ gable │ Audit │ LanceDB │ Knowledge Graph │
│ Fault- │ Trail │ ChromaDB │ Real-time Stats │
│ tolerant│ JSONL │ Abstract │ Dark Theme │
├──────────┴──────────┴───────────┴────────────────────────┤
│ Obsidian Markdown Vault │
│ (your files, your machine, git-versioned) │
└──────────────────────────────────────────────────────────┘
The entire system is local-first. Your notes, embeddings, and knowledge graph never leave your machine. The "database" is a folder of markdown files with YAML frontmatter. History is plain git — every change is a commit. Everything is diffable, portable, and yours.
How It Works: The Memory Pipeline
Step 1: Session Capture
Every Claude Cowork conversation gets saved as a structured markdown note in your Obsidian vault. This happens automatically, twice daily via scheduled tasks. Each captured session includes a summary of what was discussed, key decisions and action items, files that were created or modified, code snippets and commands that were run, and YAML frontmatter with timestamps, tags, and metadata.
The capture process strips noise — repeated prompts, error messages, verbose tool output — and preserves signal. The result is a clean, readable note that you can browse in Obsidian like any other document.
Step 2: Semantic Chunking & Embedding
Raw markdown files aren't searchable by meaning. So the RAG pipeline breaks every document into semantically coherent chunks — not by fixed character count (which splits mid-sentence), but by detecting topic boundaries using heading structure, paragraph breaks, and content similarity.
Each chunk gets an embedding vector (via your local LLM or any OpenAI-compatible endpoint), a BM25 term frequency index, TF-IDF weights for reranking, and metadata linking back to the source file, heading, and position.
The embedding runs incrementally. Changed files get re-chunked and re-embedded. Unchanged files are skipped. A full vault re-embed of ~2,000 files takes about 15 minutes on a local LM Studio instance with Nomic embeddings; incremental updates take seconds.
Step 3: Hybrid Search with Reciprocal Rank Fusion
This is the core of the RAG engine, and the single biggest quality improvement I made:
Query: "What vector database did we choose and why?"
│
├──► BM25 Keyword Search
│ Scores every chunk by exact term frequency
│ Finds: chunks containing "vector", "database", "choose"
│
├──► Vector Cosine Search (sqlite-vec)
│ Finds semantically similar chunks
│ Finds: chunks about "embedding storage decisions"
│
├──► Reciprocal Rank Fusion (RRF)
│ Merges both ranked lists with k=60
│ Prevents either method from dominating
│
└──► TF-IDF Reranking
Refines the top-N results
Boosts chunks with rare, query-specific terms
Why not just use embeddings? Because pure vector search misses exact matches. If you search for "sqlite-vec", embedding search might return results about "vector databases" in general but miss the specific chunk where you named the library. BM25 catches those exact hits. The fusion ensures you get both precision and recall.
Step 4: Knowledge Graph
Entity relationships are extracted from your vault and stored as a directed graph. People, projects, technologies, and decisions become nodes; their interactions become edges. The dashboard renders this as a D3.js force-directed graph, letting you visually explore how concepts connect across your knowledge base.
The Extension Architecture (v3.0)
In v3.0, I ripped apart the monolithic CLI and rebuilt it as a pluggable extension system.
The Problem
The original cli.py was a 1,500-line monster. Trading commands, voice synthesis, job tracking — all tangled together. Every user got every feature whether they wanted it or not.
The Solution
Every feature module is now an extension — a self-contained Python package that registers itself via setuptools entry-points:
from eidetic_os.extensions.base import EideticExtension
class TradingExtension(EideticExtension):
name = "trading"
def register_commands(self, app):
@app.command()
def trade_report():
"""Generate a trading analysis report."""
# Your trading logic here
def register_skills(self):
return ["crypto-analysis", "market-briefing"]
def register_schedules(self):
return [{"name": "morning-briefing", "cron": "0 7 * * *"}]
Install only what you need:
pip install eidetic-os # Core system
pip install eidetic-os[trading] # + trading extension
pip install eidetic-os[voice] # + voice synthesis
pip install eidetic-os[vector] # + LanceDB/ChromaDB backends
MCP Skills: Every Skill Is a Server
The Model Context Protocol (MCP) is how modern AI tools communicate. In Eidetic OS, every skill in the marketplace automatically becomes an MCP server.
Drop a SKILL.md into a directory — it describes what the skill does, its parameters, and its execution logic. The MCP skill wrapper reads the markdown, generates a JSON-RPC tool definition, and serves it over stdio or HTTP transport. Any MCP-compatible client can discover and invoke it.
eidetic skills list # List available skills
eidetic skills run security-audit --target ./app # Run a skill
eidetic mcp serve # Start the MCP server
The marketplace currently has 160+ skills spanning security auditing, DevOps automation, frontend/backend engineering, data analysis, document generation, and business tasks.
Security: Because Autonomous Code Execution Is Dangerous
Letting an AI agent run arbitrary code on your machine is terrifying. Eidetic OS takes this seriously with three layers:
Layer 1: AST Static Analysis — Before any community skill executes, the code runs through an Abstract Syntax Tree analyser. It scans for dangerous operations (os.system(), subprocess.call(), network access, file deletion) and classifies them as BLOCK (hard-stopped), WARN (logged, requires approval), or INFO (noteworthy but safe).
Layer 2: Runtime Sandbox — Even after static analysis, skills execute inside a sandboxed environment with timeout limits, memory caps, restricted filesystem access (vault-only), and no network access.
Layer 3: Audit Trail — Every autonomous action gets logged to an append-only JSONL file. The dashboard has a dedicated panel for browsing these logs with full timestamps and details.
Git Sync Hardening
When you have multiple agents writing to the same vault simultaneously, git conflicts are inevitable. v3.0 adds safe merge strategies (-X ours — vault-side always wins), YAML frontmatter validation before every commit, file-based locking with stale detection and automatic cleanup, and iCloud compatibility for Obsidian vaults synced through iCloud.
Pluggable Vector Backends
The default sqlite-vec backend works great for personal use. But if you need more, swap backends without changing a line of indexing code:
# In your config
vector_backend: "lancedb" # or "chromadb" or "sqlite" (default)
All three backends implement the same abstract VectorBackend interface. Your RAG pipeline doesn't know or care which one is running underneath.
Pluggable LLM Backends
Eidetic OS auto-detects whatever local LLM server you're running — LM Studio, Ollama, llama.cpp, or any OpenAI-compatible API. No cloud dependency. No API keys required. Everything runs on your hardware.
The Dashboard
eidetic dashboard launches a Flask web app with seven panels: System Health (vault size, embedding coverage, sync status), Audit Trail (browse every autonomous action), Scheduled Tasks (view and manage automated pipelines), Skills (browse 160+ marketplace skills), Vector Store (embedding statistics, chunk distribution), RAG Search (test queries with result explanations), and Knowledge Graph (D3.js force-directed entity visualisation).
Dark theme with slate/green accents. Server-side rendered — no npm, no build step, no React.
How It Compares
| Feature | Eidetic OS | Letta (MemGPT) | Mem0 | Khoj | gAIOS |
|---|---|---|---|---|---|
| Memory Model | Markdown vault + hybrid RAG | Git-backed virtual FS | Vector + graph fact store | TF-IDF + semantic | System prompts + wiki |
| Consolidation | Scheduled pipeline + chunking | "Sleeptime" background merging | Event-based fact extraction | Incremental indexing | Manual CLI tools |
| Vector Store | SQLite-vec / LanceDB / ChromaDB | Supabase (pgvector) | Qdrant, Neo4j, Milvus | In-memory + local | Filesystem |
| Security | AST scanner + sandbox + audit | — | — | — | — |
| Extensions | Pluggable entry-points + MCP | Parent-subagent worktrees | Thread-linked agents | Multi-agent workers | Python tools |
| Local-First | Yes (fully offline) | Partial | No (cloud required) | Yes | Yes |
| LLM Backends | LM Studio, Ollama, llama.cpp, OpenAI | OpenAI, Anthropic | Various cloud | OpenAI, Ollama | Claude Code only |
| Dashboard | Flask + D3.js (7 panels) | Web UI | — | Web UI | — |
| Skills | 160+ marketplace | Built-in | Built-in | Built-in | /wiki tools |
What It Actually Does Day-to-Day
7:00 AM — Morning briefing pipeline fires. Scans the vault, checks health, compiles a summary, emails it to you.
Throughout the day — Every Cowork session is captured automatically. Architecture decisions, debug sessions, planning — all preserved.
Any time — Search your vault: "What did we decide about authentication?" Hybrid RAG returns the exact chunk with reasoning preserved.
6:00 PM — Evening session capture. Another batch of conversations preserved.
Overnight — Embedding pipeline processes new files. Knowledge graph updates. Tomorrow's briefing compiles.
The 17+ automated pipelines include twice-daily session capture, incremental RAG indexing, morning email briefings, knowledge graph rebuilds, vault health checks, git sync and commit, trading research modules (optional), and audit trail rotation.
The Numbers
- 650+ tests, CI/CD via GitHub Actions with OIDC trusted PyPI publishing
- 160+ installable skills with marketplace, registry, and MCP server
- 3 pluggable vector backends — SQLite-vec, LanceDB, ChromaDB
- 4 LLM backends — LM Studio, Ollama, llama.cpp, OpenAI-compatible
- 7-panel dashboard with D3.js knowledge graph
- 17+ automated pipelines on configurable schedules
- Append-only JSONL audit trail for every action
- AST security scanner with BLOCK/WARN/INFO severities
- Git sync hardening with safe merge, file locking, frontmatter validation
- MIT licensed, Docker support, Python 3.9+
What I Learned
Session persistence is the killer feature. Without persistent memory, you're rebuilding context every session. This is the fundamental problem that makes all AI assistants feel disposable.
Hybrid search is worth the complexity. BM25 + vector + RRF + TF-IDF was the single biggest quality improvement. Pure embedding search sounds elegant but fails on exact matches.
Local-first is a real constraint but worth it. No cloud dependencies means it works offline and never leaks data. But you're managing your own infrastructure.
Git as the sync layer is underrated. Free versioning, branching, conflict detection. v3.0's hardening made concurrent access reliable.
Names matter more than you think. "Atlas OS" collided with a 20K-star Windows project. Every search result — buried. Rebranding was painful (176 files) but necessary. Pick a unique name from day one.
Security can't be an afterthought. The moment you let an AI execute code autonomously, you need static analysis, sandboxing, and audit logging. From the start.
What's Next: v4.0 Roadmap
#22 — Mem0-style Fact Extraction — Extract discrete facts from conversations instead of storing raw transcripts. Deduplicate against existing memory. Estimated 80% context reduction.
#23 — Sleeptime Consolidation Daemon — Background process that compresses and synthesises dialogue logs while you're offline. Resolves contradictions, merges related facts, prunes stale info.
#24 — Native Obsidian Plugin — Search, manage, and visualise your memory index directly inside Obsidian. Runs against the local server.
#25 — Interactive Setup Wizard — Guided CLI interview that auto-detects LLM backends, maps endpoints, configures vault location, profiles your preferences.
#26 — Channel Adapters — Query your knowledge base from Slack or Telegram. System runs as a local daemon.
#27 — Memory Decay Scoring — Time-weighted relevance. Recent memories boosted, stale ones decay. Prevents old context from polluting active reasoning.
Getting Started
pip install eidetic-os # Install
eidetic init # Initialise vault + detect LLMs
eidetic doctor # Check system health
eidetic embed # Index your vault
eidetic search "auth decision" # Search your knowledge
eidetic dashboard # Launch web dashboard
eidetic mcp serve # Start MCP server
The repo is at github.com/paulholland511/atlas-os (renaming to eidetic-os soon). Feedback, issues, and contributions welcome.
Update (June 2026): Renamed from Atlas OS to Eidetic OS. Shipped v3.0 with extension architecture, MCP skills, security hardening, git sync hardening, and pluggable vector backends. Published v4.0 roadmap. What started as a simple session-capture script is now a complete platform for building a persistent, secure, local-first AI operating system.
Top comments (0)