Skip to content

Latest commit

 

History

942 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Cortex

Cortex

Private local memory for your AI tools.
Install once. Your tools stop starting from scratch.

Support Cortex on Ko-fi

release 0.6.0  MIT License  Windows | macOS | Linux  Rust + React

Download  ·   Connect your tools  ·   Architecture  ·   What's new  ·   Roadmap

           


🔒 Private by default: localhost only, data never leaves your machine
🔗 One memory, every tool: HTTP and MCP, same brain, no per-tool silos
📊 Prove it works: token savings, recall quality, and Monte Carlo projections


Quick Start

Get to the first memory moment before learning daemon internals.

1. Install or build Cortex

Use the latest desktop installer, or build the 0.6.0 source CLI:

git clone https://github.com/AdityaVG13/cortex.git
cd cortex
cargo build -p cortex-daemon --release

2. Start local memory

Open Cortex Control Center and start Cortex from the app. CLI-only users can run:

cortex serve

3. Check readiness

cortex status --json

Success is "status": "ready". If status is needs_action or error, follow the returned nextAction / repair before continuing.

4. Connect one AI tool

Claude Code:

claude plugin marketplace add AdityaVG13/cortex
claude plugin install cortex@cortex-marketplace

Codex:

codex mcp add cortex -- cortex.exe mcp --agent codex

Restart the AI tool after changing MCP config.

5. Store and recall one memory

From a connected MCP client, call cortex_store, then cortex_recall. From the repo, run the matching smoke script:

Windows:

powershell -ExecutionPolicy Bypass -File scripts\first-run-smoke.ps1

macOS / Linux:

bash tests/scripts/first-run-smoke.sh

That smoke checks status, stores one disposable local memory, and recalls it. Normal use does not require benchmark adapters, provider keys, or LongMemEval.

More tool-specific setup: Info/connecting.md.



❌ Without Cortex

Session 1  →  explain preferences
Session 2  →  explain them again
Session 3  →  and again, new tool
Session 14  →  still explaining

~15,000 tokens wasted



✅ With Cortex

Session 1  →  store once
Session 2  →  boot, already knows
Session 3  →  boot, already knows
Session 14  →  boot, still knows

~300 tokens per boot (97% less)



Store   →   Recall   →   Boot

POST /store

Save decisions, lessons, preferences. Conflict detection is automatic.

GET /recall

Clock-Quorum Recall: admit a stored row when a hard anchor matches, two clocks agree, or a strong lexical hit holds. Empty is a valid answer. Use /as-of for an explicit validity time.

GET /boot

Extractive identity + delta + current-truth pack. ~300 tokens served instead of ~15,000 raw. No summarizer.


Memory tools are easy to pitch and hard to trust. Cortex starts to matter when the savings stop looking theoretical.

📊 Analytics

Savings, compression, and activity heatmaps

📈 Monte Carlo

30-day projection with confidence bands

🤖 Agents

Live sessions, inbox, deduped by identity

🎛️ Overview

Memory counts, health, and navigation


Cortex admits a memory. It does not guess a neighbor.

Gate Meaning
Hard anchor Path, symbol, alias, entity, or citation matches
Two clocks Write, truth, task, and history are independent evidence
Strong lexical Quoted phrase, stem, or closed-lexicon hit — not BM25 alone
Empty No shared handle → no result. That is correct

No local embedding or reranker model. /recall/semantic is the same engine under a compatibility name.
LongMemEval quality claims are deferred. CQR is scored on honest miss, as-of windows, and determinism — see clock_quorum contracts.

Historical v0.5.0 embedding-era numbers (not the current engine)

These were measured against a 20-query set via a helper-augmented adapter while MiniLM was still on the hot path. They are not CQR scores and are not a v0.6 quality claim.

v0.4.1 v0.5.0 Δ
Precision 55.2% 87.5% +32.3%
MRR 69.2% 95.0% +25.8%
Top-1 hit 90.0% 90.0%

Raw v0.5.0 JSON · benchmarking/README.md


v0.6.0 makes settings, governance, boot audits, and recall-quality measurement first-class. Full details in CHANGELOG.md.

Accessibility and settings

  • Settings panel: Accessibility, Appearance & Motion, Connection, Budgets, and Keyboard & Navigation
  • Runtime preferences: high contrast, reduced motion, keyboard hints, and compact navigation
  • Accessibility gates: stronger focus states, ARIA/live regions, contrast checks, and 375px reflow checks

Governance

  • Retention classes across store, MCP, OpenAPI, export, and import
  • Local endpoint budgets with stable HTTP 429 / JSON-RPC denial metadata
  • Budget UI in Control Center, backed by the local budgets.toml
  • Boot audits plus GET /boot/audit and the read-only cortex_boot_audit MCP tool
  • Admin rollback with dry-run/apply workflow and audit events

Recall quality

  • cortex-http-pure adapter as the canonical helper-free measurement floor
  • Purity gates, CAS-100, and triangle judge tooling for safer quality claims
  • Clock-Quorum Recall: deterministic evidence from write, truth, task, and history clocks. No local embedding or reranker model.

Reliability

  • Claude plugin MCP is attach-only and no longer starts a second daemon from plugin MCP paths
  • Control Center supervises the app-managed daemon and honors intentional stops
  • Handler panics return JSON 500 responses, with local panic breadcrumbs
  • Storage hygiene compacts FTS and keeps legacy embedding rows inert

Cortex tracks active agent sessions when clients identify themselves through cortex_boot or GET /boot?agent=NAME.

Connected agents in Control Center

Multi-agent, one brain

  • Each boot call registers a session. Control Center shows active sessions, deduplicated by agent identity.
  • Read-path tools (recall, peek, unfold) reattach to existing sessions. No duplicates.
  • Session descriptions preserved across reconnects and daemon restarts.
  • What one agent stores, every other agent can recall.

Claude Code, Codex, Cursor, and custom scripts can all be connected simultaneously. Each tracks its own session while sharing the same memory.


Tool Connection Setup
Claude Code MCP (plugin) or desktop app Plugin: claude plugin install cortex@cortex-marketplace
Codex MCP codex mcp add cortex -- cortex.exe mcp --agent codex
Cursor MCP Point MCP server at cortex mcp --agent cursor
Factory Droid MCP cortex mcp --agent droid
Aider CLI / HTTP cortex boot --agent aider
Custom tools HTTP Three endpoints: /boot, /recall, /store
Local LLMs HTTP / MCP Same protocol, any runtime

Full setup guide: Info/connecting.md


Desktop app (Control Center)
Download from the latest tagged release page. The Control Center manages daemon lifecycle for you.

Platform Desktop installer Daemon archive
Windows .exe (NSIS installer) .zip
macOS .dmg .tar.gz
Linux .AppImage / .deb .tar.gz

Current release: v0.6.0.

From source

git clone https://github.com/AdityaVG13/cortex.git
cd cortex
cargo build -p cortex-daemon --release

Claude Code plugin

claude plugin marketplace add AdityaVG13/cortex
claude plugin install cortex@cortex-marketplace

The plugin attaches to a running Cortex runtime. If Cortex is not ready, it reports APP_INIT_REQUIRED; open Control Center or start the local runtime, then retry.


Cortex enforces a single-daemon invariant: only one daemon process runs at a time.

Mode How it works
Desktop app Control Center owns the daemon. Restart and monitor from the app.
CLI cortex serve starts the daemon. Exits cleanly if one is already running.
Plugin Attach-only MCP bridge. It connects to the running app/service daemon and does not silently spawn a second daemon.

Default bind: 127.0.0.1:7437. Non-loopback binds require TLS. Auth token at ~/.cortex/cortex.token.
If using the Control Center, manage the daemon from there. Do not run a second cortex serve alongside it.


After installing, verify the product path:

cortex status --json

Windows:

powershell -ExecutionPolicy Bypass -File scripts\first-run-smoke.ps1

macOS / Linux:

bash tests/scripts/first-run-smoke.sh
Development build verification
# Daemon contract tests
cargo test -p cortex-tests

# Desktop test suite
npm --prefix desktop/cortex-control-center test

# Lifecycle smoke test
npm --prefix desktop/cortex-control-center run verify:lifecycle:dev

# Security audit
npm audit --omit=dev --audit-level=high
cargo audit

Document Covers
Docs index All product and operator docs
Connecting Setup, MCP, HTTP, auth, troubleshooting
Architecture Store, CQR, boot, schema, crate map
MCP Tools All 29 MCP tool definitions and parameters
Roadmap What shipped and what's next
Security Threat model, auth rules, vulnerability reporting
Team mode Shared-server setup for engineering teams
Contributing Development setup and PR guidelines
CLI reference
Command Description
cortex serve Start the daemon
cortex mcp MCP stdio bridge to the running daemon
cortex --help Full command reference
cortex doctor Run diagnostics
cortex paths --json Show file and port paths
cortex status --json Local memory readiness and next action
cortex rebuild-anchors Rebuild derived clock projections
cortex setup --team Initialize team mode and generate API keys
cortex export Export data (json or sql)
cortex import Import from a previous export
cortex admin rollback --session-id <id> Soft-delete a session's memory writes (dry-run default; --apply to persist)

Cortex defaults to localhost-only access with bearer-token auth.
Full threat model, auth rules, and vulnerability reporting: Info/security-rules.md


How much disk space does Cortex use?
The daemon binary is ~30 MB. The SQLite database grows with usage. Clock-Quorum Recall does not download or load a local model. Older installs may still have leftover files under ~/.cortex/models; they are unused.
Can multiple agents write to Cortex at the same time?
Yes. SQLite WAL mode handles concurrent reads and serialized writes. Each agent maintains its own session while sharing the same memory. Conflict detection handles contradictions automatically.
Does Cortex send any data externally?
No. In solo mode, Cortex runs entirely on localhost. No telemetry, no phone-home, no cloud sync. Team mode sends data only to the configured team server over your network.
What happens if the daemon crashes mid-session?
The MCP proxy detects daemon death and restarts automatically (bounded to 3 attempts with backoff). SQLite WAL mode ensures no data corruption. Sessions survive transient crashes.
How do I reset Cortex to a clean state?
Delete ~/.cortex/cortex.db and restart the daemon. A new empty database and auth token are generated. Control Center settings are preserved. No model download is required.

Built by


Support Cortex  ·   Docs  ·   Connecting  ·   Security  ·   Contributing  ·   Code of Conduct  ·   Changelog  ·   MIT License

About

Persistent shared memory and context compression for AI coding agents. Local-first Rust daemon with HTTP, MCP, and a desktop control center.

Topics

Resources

Code of conduct

Contributing

Stars

9 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages