🧬 Take your AI's memory anywhere.

A local-first, git-like portable memory layer for every AI coding agent.

Helix gives your AI a long-term memory that belongs to you — your preferences, your projects, your decisions, your coding style — and lets you carry it across Claude Code, Cursor, Copilot, Windsurf, ChatGPT, Gemini, and any MCP-compatible agent.

One memory. Every agent. Owned by you.

Product Requirements · Technical Spec · Architecture · Decisions · Roadmap

---

The problem

Every AI agent you use is slowly learning who you are — your stack, your conventions, the architecture of the project you've explained five times, the fact that you prefer pytest over unittest and tabs in Go but spaces everywhere else.

Then you switch tools. Or the session ends. Or the context window fills up. And it's gone. You start from zero, re-explaining yourself to a machine that should already know.

Today that memory is:

• Trapped — locked inside one vendor's cloud (ChatGPT memory ≠ Claude memory ≠ Cursor memory).
• Opaque — you can't see it, edit it, audit it, or delete a single wrong fact.
• Not yours — it lives on someone else's servers, under someone else's terms.
• Not portable — there is no "export my brain and import it elsewhere."

The idea

Helix is a memory layer that lives with you, not with a vendor.

It watches the conversations and code you choose to share, extracts durable facts, stores them locally as a structured knowledge graph, and serves them back to any agent through the open Model Context Protocol (MCP) — so every tool you use wakes up already knowing you.

The whole thing is packaged as a portable, signed, encrypted file: a .dna strand. Move it between laptops. Sync it to a teammate. Version it like code. Roll it back when an agent learns something wrong.

  ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
  │  Claude Code │     │    Cursor    │     │   ChatGPT    │
  └──────┬───────┘     └──────┬───────┘     └──────┬───────┘
         │  MCP               │  MCP               │  MCP
         └────────────────────┼────────────────────┘
                              ▼
                   ┌─────────────────────┐
                   │     Helix Engine    │   extract · store · recall · consolidate
                   │  (runs on YOUR box) │
                   └──────────┬──────────┘
                              ▼
                     🧬  your-brain.dna
                  (signed · encrypted · versioned)

Why this is different

	ChatGPT/Claude memory	Mem0 / OpenMemory	Helix
Works across vendors	❌	✅ (MCP)	✅ (MCP)
Local-first / offline	❌	partial	✅ default
You can read & edit every fact	❌	partial	✅ full graph UI
Coding-aware (repos, stacks, decisions)	❌	❌ generic	✅ first-class
Portable single-file export	❌	❌	✅ .dna
Git-like (diff / merge / rollback / branch)	❌	❌	✅
Default running cost	$$	$/cloud	$0 (local embeddings)
Team / org shared memory	❌	enterprise	✅ shareable strands

Walrus Memory proved people want portable, verifiable agent memory. Mem0 proved the extraction/consolidation engine works. Helix is what happens when you make that coding-native, local-first, free to run, and as easy to move around as a git repo.

What Helix remembers

Helix doesn't store raw chat logs. It distills them into a typed memory graph:

• Identity — who you are, role, expertise, tooling.
• Preferences — style, formatting, libraries you like/avoid, how you want to be talked to.
• Projects — architecture, services, conventions, gotchas, "why we did it this way."
• Decisions — durable choices and their rationale (your personal ADR log).
• People & teams — collaborators, ownership, who knows what.
• Snippets & patterns — reusable code idioms you keep reaching for.

Every node is timestamped, sourced, confidence-scored, and editable.

Quick start

These commands work today (run from source during alpha; once published on PyPI it'll be pipx install helix-dna):

# from a clone: put the packages on the path, then use the `helix` CLI
uv sync                       # or: pip install pynacl mcp typer rich fastembed

helix init                    # create your local strand
helix add "We chose Postgres over Mongo for billing — needs ACID." --scope project:billing
helix add "All API errors use RFC-7807." --scope project:billing
helix search "which database for billing and why" --scope project:billing   # ranks the decision

helix connect cursor          # wire Helix into an agent over MCP (also: claude-code, vscode, …)
helix dashboard               # browse / edit / curate in your browser (localhost)

# take it anywhere — signed + encrypted + chunked .dna
helix export my-brain.dna     #  verify offline with: helix verify my-brain.dna
helix import my-brain.dna --as work          # on another machine
helix merge teammate.dna                      # combine memories (conflict-aware dedup)
helix push  ~/Dropbox/team    # encrypted team sync (push/pull a shared .dna)
helix log                     # git-style history
helix eval                    # the built-in recall-quality benchmark

By default Helix runs 100% locally and free: local embeddings (bge-small via fastembed when installed, else a dependency-free hashing embedder), an embedded vector + graph store in one SQLite file, and an LLM router that only calls a model when it needs one — preferring a free tier. See Cost Optimization.

Full CLI: init · add · ingest · search · context · list · forget · relate · maintain · reflect · dashboard · relay · connect · export · verify · import · merge · diff · rollback · push · pull · export-md · log · eval · doctor. (ingest seeds memory from a markdown/notes file or folder; reflect distills clusters of facts into higher-level insights; export-md dumps memory as human-readable Markdown; relay runs a thin sync server.)

Documentation

Product & strategy

Doc	What's inside
PRD	Vision, personas, problem, scope, requirements, metrics, GTM
Competitive Analysis	11-product teardown + the 6-axis positioning table
Business Model & GTM	Open-core, pricing principles, growth loops
Roadmap	Phased plan from MVP to platform
Research Survey	The cited literature/landscape behind every decision

Engineering

Doc	What's inside
Technical Spec (TSD)	Components, data model, APIs, algorithms, tech choices
System Architecture	Diagrams, data flow, deployment, scaling, trust boundaries
Memory Model	Typed graph schema: episodic/semantic/procedural + bi-temporal
Consolidation, Decay & Reflection	CLS two-stage, decay/reinforcement, reflection, sleep-time
Retrieval Pipeline	Hybrid + RRF + graph PPR + MMR; no LLM on the hot path
.dna Format	The portable, signed, encrypted bundle spec
Sync & Merge	Optional E2E sync; CRDT + 3-way semantic merge
Cost Optimization	How Helix stays at ~$0
API Reference	MCP tools, local daemon REST, SDKs
MCP Integration	Tools/resources exposed to agents
Plugins & Extensions	Pluggable embeddings/stores/LLM/connectors
Observability	Local metrics + the "$0" cost dashboard

Trust, quality & process

Doc	What's inside
Security Model	Encryption, signing, threat model, anti-poisoning
Privacy & Compliance	Redaction, GDPR erasure cascade, never-fine-tune
Evaluation & Benchmarks	LongMemEval, the coding-memory benchmark gap, harness
Governance & RFCs	Roles, RFC process, versioning, commercial layer
Decisions (ADR)	Every meaningful choice + why, and what changed (30 ADRs)
Glossary	Shared vocabulary
CLAUDE.md	Guidance for AI agents working in this repo

Project status

Alpha — working. The core product is built and tested (67 tests; ruff + black + mypy clean). Shipped so far:

• Local memory ($0/offline): redact → gate → extract → embed → consolidate → store, with hybrid (dense + keyword + graph) retrieval, decay/reinforcement, and bi-temporal facts.
• MCP server + helix connect for 8 clients (Claude Code/Desktop, Cursor, Windsurf, VS Code, Gemini, Zed, Codex) and a --path override for any other.
• Optional LLM router (free-tier-first Gemini → gpt-4o-mini → Ollama), cached + budgeted.
• Portable .dna — signed (Ed25519), encrypted (XChaCha20-Poly1305, chunked), versioned; export/verify/import/merge/diff/rollback, re-embed on import.
• Dashboard (browse/search/add/edit/forget, provenance, history, graph) and team sync (encrypted push/pull).
• SDKs (Python + TypeScript) and a built-in recall benchmark (helix eval).

v2 / Wave A is landing now (docs/V2_PLAN.md, "Git for your AI's memory"): secret + PII gate, conflict surfacing, staleness detection, tighter packing, erasure cascade + tombstones + DSAR, sleep-time consolidation, an optional reranker, scoped redacted sharing with quarantine, a memory copilot (helix about), an observability + $0-meter surface, and LangGraph/AutoGen adapters — all $0/offline, behind 13 new helix commands.

Plus a redesigned local dashboard (helix dashboard — copilot, canvas knowledge graph, review queue, $0-meter + heatmap, bitemporal time-travel, audit, cmd-K, and a "watch the graph assemble itself" first-run), per-fact Ed25519 signing, procedural/skill memory, a GitHub/repo connector (helix repo), and VS Code + browser extensions (editors/vscode, apps/browser-extension).

Still phased (see the Roadmap): BLAKE3 + S3 sync backend, PyPI packaging, and the portable-memory open standard.

License

Apache-2.0. Your memory is yours; the engine is open.

_{Built in the open. Memory should belong to the human, not the model.}