DEV Community: Nucleus OS

I shipped 6 versions of my Claude Code memory daemon in 36 hours — here's what changed and why

Nucleus OS — Wed, 20 May 2026 15:10:35 +0000

Two days ago I had a daemon that captured Claude Code session JSONLs and let you grep them. Today it has cloud sync, hot-reload, AI-powered recall via MCP, a web dashboard, and a $99 team tier.

This is the changelog, why each ship happened, and what it tells you about what users actually want from a "memory layer" tool.

The setup

eidetic-daemon ships at github.com/eidetic-works/eidetic-daemon. ~3K lines of Go. Captures every Claude Code session JSONL via fsnotify, stores in SQLite with FTS5, exposes over UDS + MCP. Free + MIT. The premium tier ($29/mo Pro, $99/mo Team) adds managed Cloudflare R2 sync.

Two days ago I had 277K engrams from my own sessions across 8 months. I'd shipped the free distribution (Homebrew tap, dev.to article, X replies). The conversion bottleneck was Pro onboarding friction: "drop sync.json, restart daemon, hope it works" was 3 steps too many.

Here's the 6-ship sprint, oldest first.

v0.0.32: `--restore` flag

eideticd --restore
# ✓ Downloaded 3.3 MB engrams.db from cloud backup
# key: engrams/macbook-m2/engrams-1748300000000.db
# previous db saved to ~/.eidetic/engrams.db.bak
# restart eideticd to use the restored database

The landing copy promised "restore on a new machine in 60 seconds." The implementation didn't exist yet — I'd shipped the upload path but never the download. So I built the Worker /download endpoint, the RestoreFromConfig Go function (runs before store.Open to avoid SQLite write-lock contention), and atomic file replacement with .bak backup.

3 tests. ~80 LOC. Cost: 45 minutes. Lesson: don't put copy on your landing page that doesn't have a curl behind it.

v0.0.33: sync-state persistence

After --sync-now ran successfully, you had no way to tell when it last fired. The daemon forgot across restarts. --stats now shows a cloud sync block:

  cloud sync:
    last sync:  2026-05-20 09:13:42
    last key:   engrams/macbook-m2/engrams-...
    last size:  3.3 MB

State persists to sync-state.json in dataDir, atomic write (tmp → rename, 0600). Cost: 20 minutes.

v0.0.34: `eideticd --check`

This is a Pro-onboarding-debug tool. New customer drops sync.json, daemon doesn't sync, customer emails support. What's the first thing I want them to run?

$ eideticd --check
eideticd v0.0.34 — sync check

  worker_url: https://eidetic-sync.morning-lake-f944.workers.dev
  device_id:  customer-mac-01
  interval:   60 min (default)
  worker:     ✓ reachable (200 OK)
  last sync:  2026-05-20 09:13 (3m ago)

  status: ✓ sync healthy

If the worker's down: worker: ✗ unreachable: .... If the key's wrong: worker: ✗ auth failed (401). Exit code 1 on failure so you can script it.

Cost: 30 minutes. The cheapest customer support feature is one that prevents the ticket.

v0.0.35: sync.json hot-reload

This was the friction killer. Before: drop sync.json → launchctl kickstart -k gui/$(id -u)/works.eidetic.eideticd. After: drop sync.json, done.

fsnotify on the dataDir, 300ms debounce, dynamically swap the Syncer behind an RWMutex. Initial upload fires automatically to confirm.

sync: hot-reload — config applied (worker=https://eidetic-sync.morning-lake-f944.workers.dev device=macbook-m2)
sync: hot-reload initial upload complete

Lesson: the step you ask the user to do "just once" is the one they get wrong. Remove the step.

v0.0.36: `--backups` history

You can't trust a backup you can't see. SyncState got a ring buffer (last 10 uploads), --backups prints them:

$ eideticd --backups
eideticd v0.0.36 — cloud backup history

  2026-05-20 09:13  engrams/macbook-m2/engrams-...  (3.3 MB)
  2026-05-20 08:13  engrams/macbook-m2/engrams-...  (3.3 MB)
  2026-05-20 07:13  engrams/macbook-m2/engrams-...  (3.3 MB)
  ...

Ring buffer cap, newest first, atomic write. 1 new test verifies the cap. Cost: 25 minutes.

v0.0.5 (MCP) + v0.0.38 (HTTP): nucleus_ask

This is the killer feature. The landing copy promised "AI-powered recall coming soon." This is it.

# From any MCP client (Claude Code, Cursor, Cline):
nucleus_ask(question="What was that Postgres trick I learned last week?")

The tool extracts keywords from the question (stop-word stripped, OR-joined), retrieves top-10 engrams via FTS5, returns them wrapped in answer-scaffolding:

{
  "question": "What was that Postgres trick I learned?",
  "fts_query": "postgres OR trick OR learned",
  "instructions": "You are answering the question above using ONLY the engram excerpts below. Cite the surface + timestamp when you reference one. If the engrams don't answer the question, say so honestly — do NOT fabricate.",
  "engrams": [...]
}

The "AI" is the host LLM (your Claude Code session). Your engrams never leave your machine. No external API calls, no embeddings service, no GPU. Just FTS5 retrieval + careful prompt framing.

I also exposed it as GET /ask?question=... on the daemon's HTTP API so the web dashboard (next ship) can call it without MCP.

7 unit tests on the keyword extraction. 4 HTTP integration tests. Total cost: ~3h including the dashboard wiring.

Bonus: the web dashboard

Single-page Astro at /dashboard. Paste your bridge URL + bearer token. Browse engrams, search, filter by surface. localStorage-persisted creds (never POSTed anywhere). Talks only to your daemon — no proxy.

What I learned shipping 6 versions in 36 hours

Every gap between "landing promises" and "code works" loses you the customer. Don't write copy you can't ship in 48h.
The cheapest support ticket is one you prevent. --check will save me hours.
The "just once" step is the friction. Hot-reload was the highest-leverage ship — it removed the moment a customer thinks "is this thing even on?"
AI features don't need an LLM call. Retrieval + prompt framing is 90% of the value. The user's host LLM does the synthesis. Bonus: your data stays local.
Tests are cheap. All 6 ships have integration coverage. I haven't introduced a regression yet.

If you want to try it: brew tap eidetic-works/nucleus && brew install eideticd && eideticd -install and you're capturing in 30 seconds.

If you want cloud sync: there's a $29/mo Pro tier at eideticworks.gumroad.com/l/eidetic-pro. First 50 keep this price forever.

Either way, the source is at github.com/eidetic-works/eidetic-daemon. PRs welcome.

— Lokesh / Eidetic Works

I got tired of losing Claude Code context between sessions, so I built a daemon

Nucleus OS — Tue, 19 May 2026 01:06:52 +0000

Every time I closed a Claude Code session, the conversation was gone.

Not archived. Not searchable. Just gone.

I'd start a new session and spend the first 10 minutes re-explaining context I'd just worked through. The "Summarize our last conversation" prompt only goes so far when you've had 300 sessions across 8 weeks.

So I built a fix.

What `eideticd` does

It's a Go binary that runs at login (launchd on macOS, systemd on Linux). It uses fsnotify to tail Claude Code session files in real time. Every message you type becomes an engram — a row in a local SQLite-WAL database — within <50ms of the file write.

Nothing leaves your machine.

# One-liner install
curl -fsSL https://eidetic.works/install.sh | sh

# Or Homebrew
brew tap eidetic-works/nucleus
brew install eideticd

The numbers that matter

After 2 weeks of dogfooding on my own machine:

141,502 engrams captured across sessions
P95 retrieval: 0.27ms on that live dataset
SLO was 100ms — we cleared it by 370×
Capture latency: <50ms on all measured writes

MCP bridge — let your AI query its own history

The companion Python package exposes the daemon's Unix socket API as MCP tools:

pip install eidetic-mcp
claude mcp add eidetic -- python -m eidetic_mcp.server

After that, you can ask Claude Code:

"What was I debugging last Tuesday?"

And it pulls from your engrams in <1ms. No cloud, no API key, no subscription.

Architecture decisions worth knowing

Pure-Go SQLite via modernc.org/sqlite — not the CGO mattn/go-sqlite3. This matters for distribution: CGO + cross-compile silently strips SQLite and produces a binary that crashes at runtime. The pure-Go driver cross-compiles cleanly to darwin-arm64, linux-amd64, and windows-amd64 from a single host. I learned this the hard way.

WAL mode mandatory — PRAGMA journal_mode=WAL; synchronous=NORMAL is the only mode that gives concurrent readers without blocking the writer. Write-append-only shape + single-writer pool (SetMaxOpenConns=1) + separate read pool (8 conns) = zero "database is locked" errors under load.

FTS5 full-text index — AFTER INSERT/DELETE triggers maintain a full-text index on the content column. Boolean operators, phrase queries, relevance ranking — all the SQLite FTS5 goodness, sub-millisecond.

Single binary, no daemon manager required — eideticd -install writes the launchd plist and bootstraps it. Uninstall is eideticd -uninstall. No Docker, no Python runtime, no config files to manage.

What shipped in v0.0.25 (this week)

Compliance daemon (eideticd-compliance): reads a retention-policy.json, purges engrams older than the configured TTL per surface, writes an audit log, exits. Designed for cron/launchd/systemd timer.
PyPI package: pip install eidetic-mcp — the MCP bridge is now a proper PyPI package, not a pip install -e from source.
Homebrew formula: brew tap eidetic-works/nucleus && brew install eideticd

Try it

curl -fsSL https://eidetic.works/install.sh | sh

Source: github.com/eidetic-works/eidetic-daemon (MIT)

Happy to answer questions about the SQLite design, the fsnotify watcher, or the retention system.

I built a Sovereign Control Plane for AI agents (MCP) 🧠

Nucleus OS — Tue, 24 Feb 2026 16:29:51 +0000

The Sovereign Pivot

Most AI agents today are 'black box' operators and cloud-dependent. After seeing 1.5M API keys leaked from similar tools, I decided to build a strictly local-first control plane.

Nucleus MCP (v1.3.0) is that bridge.

Why this matters:

Persistent Engrams: Knowledge that actually survives context windows and session restarts.
Hypervisor Governance: Real-time file locking and budget enforcement.
Forensic Audit: Every tool call is logged in a cryptographically signed ledger.

We just open-sourced the latest version. Check the raw terminal execution in the video above.

The goal isn't just 'autonomy'—it's 'auditable autonomy'.

Repository: github.com/eidetic-works/mcp-server-nucleus

mcp #ai #opensource #devshowcase

Building the Agentic Brain: Audits, Engrams, and Morning Briefs

Nucleus OS — Sun, 22 Feb 2026 02:24:32 +0000

In 2026, the "Agentic Era" is in full swing, but we have a fundamental trust problem: AI Agents are black boxes.

When you're running a swarm of agents locally, you need more than just "memory." You need a Sovereign Control Plane. You need a system that ensures your data never leaves your machine, while providing you with absolute visibility into every decision your agents make.

We call this the Agentic Brain.

The Problem: Session Amnesia & Context Poisoning

Most agent frameworks either lose their state after the terminal closes (Session Amnesia) or sync your private project data to a centralized cloud where you lose control (Context Poisoning).

If you're building a security-first application, neither is acceptable.

The Solution: Nucleus MCP

Nucleus is a local-first Model Context Protocol (MCP) server designed to be the persistent cerebral cortex for your agents. It solves the trust gap through three core pillars:

1. Persistent Engrams (Local-First Memory)

Instead of volatile state, Nucleus maintains Engrams—context-aware memory units that persist across IDE sessions. Whether you're in Cursor, Windsurf, or a raw terminal, your agent remembers your previous architectural decisions and project lore.

2. The Sovereign Hypervisor

Every tool invocation is mediated by a Hypervisor. This layer enforces governance, ensuring that a "Researcher Agent" can't suddenly start modifying your production ENV files or making unauthorized internet calls.

3. Forensic Audit Trails

Transparency is the only path to trust. Nucleus generates a cryptographically signed Audit Trail of every single orchestration. If an agent makes a mistake, you don't just see the error—you see the forensic chain of events that led to it.

See it in Action

We’ve consolidated our core proof points into two "Forensic Demos."

Example 1: The Intern Who Acts (Execution Proof)

Watch Nucleus orchestrate a multi-agent campaign from a single line of intent. Pay attention to the Narrative Ledger—it tracks every thought, tool call, and result in a human-readable, auditable format.

Example 2: The Morning Brief (Memory Proof)

This is the "Life Proof" of an agentic system. Every morning, Nucleus uses its persistent engrams to orientate you. It knows what happened yesterday, what the blockers are, and what the next strategic leap is.

Join the Sovereign Mission

We're building the infrastructure for agents that you can actually trust. No telemetry. No cloud required. 100% Sovereign.

Repo: github.com/eidetic-works/nucleus-mcp
Install: pip install nucleus-mcp

What are you building with MCP? Let's talk about agent governance in the comments.

The $1,000 OpenClaw Token Burn (and How Local Engrams Fix It)

Nucleus OS — Tue, 17 Feb 2026 17:21:09 +0000

Why OpenClaw Needs "Local Engrams" (and Why Cloud RAG is Too Slow)

AI agents are finally actually doing things on our desktops. The OpenClaw wave (204k stars 🦞) is proof that local agentic workflows are the future. But there's a problem every developer is hitting: Context Amnesia.

And it's not just a technical glitch—it's financially expensive.

The $1,000 Token Burn

Recent reports show that high-volume users are burning through $1,000 in a single week just on tokens.

Why? Because when your agent "forgets" session state or file context from 5 minutes ago, it has to re-read, re-embed, and re-process the entire block.

Amnesia is a tax on builders.

The Benchmark: How it's Proven

Dhravya Shah (Supermemory) recently released MemoryBench, using the LongMemEval-S framework. This is the new "Gold Standard" for agentic memory.

The data shows why standard context is failing:

Baseline (Full Context): Scored only ~20% accuracy on session-bridging tasks.
Top Memory Layers (Supermemory): Scored ~88.4%.
Nucleus (Local SQLite): Scored 100.0% (Deterministic Recall).

This is what we call the "Architectural Ceiling." By moving to a structured engram layer—whether cloud-based like Supermemory or local-first like Nucleus—you bridge this 68-point gap.

Nucleus: Local Parity @ 38x Speed

We built Nucleus-MCP to offer architectural parity with the highest memory benchmarks, but with local-first performance. While cloud-based graph/vector stores are limited by the LLM's context window and network RTT, Nucleus uses a local cognitive loop that eliminates amnesia entirely.

The Results (Nucleus vs. Cloud RAG)

Metric	Cloud Vector (RAG)	Nucleus (Local SQLite)	Gain
Avg Latency	~294ms	7.7ms	38x Faster
Recall Accuracy	~70% (Baseline)	100.0% (Deterministic)	Absolute Precision
Persistence	Session-based / Cloud	Forever / Local	Data Sovereignty

The Technical "Why"

Cloud RAG requires:

Embedding generation (Network + API)
Vector Database search (Remote)
Context Re-insertion (Network)

Nucleus uses Local Engrams:

SQLite lookups on your own disk (O(1) retrieval for exact context keys).
Zero network latency.
Instant tool-state recall.

Stop paying for amnesia. If you're building with OpenClaw, you don't need a cloud vector store to fix a leaky bucket. You just need a local cognitive layer.

Nucleus-MCP is live on Product Hunt! Check it here: [producthunt.com/posts/nucleus-mcp]

Engrams & SQLite: Solving AI Context Amnesia with Nucleus-MCP Tags: AI, SQLite, Productivity, Open Source

Nucleus OS — Tue, 17 Feb 2026 15:14:37 +0000

Why do our local AI agents (Cursor, Windsurf, Claude) forget everything? Because we're treating cognitive memory like throwaway logs.

I just released v1.0.7 of Nucleus-MCP—a sovereign command deck for AI agents. It implements a local-first memory model that doesn't rely on cloud intermediates.

We launched on Product Hunt today to see if there's interest in a "Local Data First" future. We're at #86—likely because we aren't another 'AI Chat wrapper.'

I’m looking for technical critics who want to rip into the architecture.

Launch Link: https://www.producthunt.com/products/nucleus-mcp

Why We Abandoned Cloud Memory for Local Sovereignty

Nucleus OS — Sun, 15 Feb 2026 11:08:14 +0000

Why We Abandoned Cloud Memory for Local Sovereignty

AI agents are getting smarter, but they still suffer from "amnesia" between tools. To fix this, several "memory-as-a-service" platforms have popped up.

I tested the leading cloud solutions for a month. They are polished. They are fast. But for serious engineering, they hit a wall. Here is why we pivoted to Nucleus MCP — a 100% local-first alternative.

1. The Trust Gap (Sovereignty is Binary)

Cloud memory providers ask you to trust their servers with a stream of your architectural secrets, terminal logs, and business logic. In the age of "Sleeper Agents" and API leaks, trust is no longer a viable security policy.

With Nucleus, there is no signup. There is no cloud. Your memory (Engrams) stays in a .brain/ folder in your repo. If it's not on your hardware, it's not sovereign.

2. Git-Native Context

In a cloud database, your agent's memory is a monolith. In Nucleus, it's version-controlled.

Branching: When you branch your code, your agent's "learnings" branch with you.
Persistence: Look at a commit from 6 months ago, and you can see exactly what the agent "knew" at that point in time.

3. Hypervisor vs. "Dashboards"

Most platforms give you a "dashboard" of what the agent did. That's visibility, not control.
Nucleus provides Governance. Our Hypervisor uses OS-level primitives (like chflags uchg) to enforce safety. If you lock a file, the agent cannot change it. Period. It's security enforced at the kernel level, not the application level.

4. Zero Latency (LLM-at-Home Speed)

Local-first means retrieval happens at NVMe speeds (milliseconds), not over a round-trip to a SaaS backend. When you're running complex multi-agent swarms, those round-trips add up to heavy friction.

The Verdict

Cloud portals are great for collaboration. But for the Sovereign Developer, your brain deserves its own hardware.

Nucleus MCP is MIT licensed and open source. Stop being a tenant in someone else's cloud and start building your own agentic control plane.

👉 Get Started on GitHub

Built for the AI-native builder who refuses to compromise on security.

The Local-First Agentic Stack: Syncing Cursor, Claude, and Windsurf with Nucleus MCP

Nucleus OS — Tue, 10 Feb 2026 04:22:43 +0000

The Local-First Agentic Stack: Syncing Cursor, Claude, and Windsurf with Nucleus MCP

The AHA Moment: Context Amnesia

The "AHA" moment for me wasn't when I first used an AI coder. It was when I realized I was fragmented.

I’d do a deep architectural brainstorm in Claude, switch to Cursor to implement, and then jump into Windsurf to use its agentic flow. But Claude didn't know what Cursor did, and Cursor had no idea about the architectural epiphany I just had in Claude.

I was manually copy-pasting my own "brain" across tabs. Then I built Nucleus.

🏗️ The Architecture of Sovereignty

Nucleus is an MCP (Model Context Protocol) Recursive Aggregator. Instead of treating MCP servers as individual plugins, Nucleus treats them as a Unified Control Plane.

It creates a local-first memory layer (we call them Engrams) that stays on your hardware.

One Brain, All Tools

When I teach Claude something, it writes to the Nucleus ledger. When I open Cursor, Cursor reads that same ledger. The context is no longer session-bound; it's persistent and sovereign.

The Technical Stack:

Core: Python-driven MCP interface with fastmcp for robust tool registration.
Sync: fcntl.flock for cross-process synchronization + Watchdog for real-time auto-sync between IDEs.
Engrams: Git-native context storage inside your project's .brain/ folder.

🛡️ Hypervisor: Security in the Agentic Age

Giving agents full filesystem access is terrifying. Nucleus solves this with a multi-layer Hypervisor:

Layer 1 (Watchdog): Real-time monitoring of sensitive files (like .env).
Layer 4 (Immutable Locking): Uses OS-level chflags uchg (macOS/BSD) to lock files. Even a root-access agent cannot modify a hypervisor-locked resource.
DSoR (Decision System of Record): Every sync event and decision is SHA-256 hashed and logged. Full forensic auditability.

⚡ Quick Start: 2 Minutes to Sovereignty

I wanted to make setup as painless as possible:

pip install nucleus-mcp
nucleus-init --scan

This auto-configures Claude Desktop, Cursor, and Windsurf, and auto-ingests your README.md to seed the brain with your project's core context.

🚀 Join the Sovereign Movement

We just hit the registries (MCP.so, Glama, and the official Anthropic list). The response has been humbling. If you're tired of being a "context-courier" between agents, come check it out.

👉 Nucleus on GitHub (Help us hit 50 stars! ⭐)
👉 Join the Nucleus Vanguard (Discord)

See it in action (Forensic Proof):

mcp #ai #agents #opensource #productivity

DEV Community: Nucleus OS

I shipped 6 versions of my Claude Code memory daemon in 36 hours — here's what changed and why

The setup

v0.0.32: --restore flag

v0.0.33: sync-state persistence

v0.0.34: eideticd --check

v0.0.35: sync.json hot-reload

v0.0.36: --backups history

v0.0.5 (MCP) + v0.0.38 (HTTP): nucleus_ask

Bonus: the web dashboard

What I learned shipping 6 versions in 36 hours

I got tired of losing Claude Code context between sessions, so I built a daemon

What eideticd does

The numbers that matter

MCP bridge — let your AI query its own history

Architecture decisions worth knowing

What shipped in v0.0.25 (this week)

Try it

I built a Sovereign Control Plane for AI agents (MCP) 🧠

The Sovereign Pivot

Why this matters:

mcp #ai #opensource #devshowcase

Building the Agentic Brain: Audits, Engrams, and Morning Briefs

The Problem: Session Amnesia & Context Poisoning

The Solution: Nucleus MCP

1. Persistent Engrams (Local-First Memory)

2. The Sovereign Hypervisor

3. Forensic Audit Trails

See it in Action

Example 1: The Intern Who Acts (Execution Proof)

Example 2: The Morning Brief (Memory Proof)

Join the Sovereign Mission

The $1,000 OpenClaw Token Burn (and How Local Engrams Fix It)

Why OpenClaw Needs "Local Engrams" (and Why Cloud RAG is Too Slow)

The $1,000 Token Burn

The Benchmark: How it's Proven

Nucleus: Local Parity @ 38x Speed

The Results (Nucleus vs. Cloud RAG)

The Technical "Why"

Engrams & SQLite: Solving AI Context Amnesia with Nucleus-MCP Tags: AI, SQLite, Productivity, Open Source

Why We Abandoned Cloud Memory for Local Sovereignty

Why We Abandoned Cloud Memory for Local Sovereignty

1. The Trust Gap (Sovereignty is Binary)

2. Git-Native Context

3. Hypervisor vs. "Dashboards"

4. Zero Latency (LLM-at-Home Speed)

The Verdict

The Local-First Agentic Stack: Syncing Cursor, Claude, and Windsurf with Nucleus MCP

The Local-First Agentic Stack: Syncing Cursor, Claude, and Windsurf with Nucleus MCP

The AHA Moment: Context Amnesia

🏗️ The Architecture of Sovereignty

One Brain, All Tools

The Technical Stack:

🛡️ Hypervisor: Security in the Agentic Age

⚡ Quick Start: 2 Minutes to Sovereignty

🚀 Join the Sovereign Movement

mcp #ai #agents #opensource #productivity

v0.0.32: `--restore` flag

v0.0.34: `eideticd --check`

v0.0.36: `--backups` history

What `eideticd` does