Cortex is a Project Memory OS that gives AI coding assistants a permanent, layered brain for your codebase.

It ensures Claude (and eventually Cursor, Cline, Windsurf) never forgets what you built, why you built it, what you decided, and what went wrong -- across sessions, across team members, across projects.

It ships as a VSCode extension + CLI tool, runs 100% locally, and integrates with Claude Code via its native hooks system.

Every AI coding tool today has amnesia. Cortex gives them a brain.

1. 3-Layer Memory Architecture (Nobody Has This)

LAYER 1: WORKING MEMORY (hot)     -- Always injected, ~800 tokens
   Last 3 sessions, current sprint, recent decisions

LAYER 2: EPISODIC MEMORY (warm)   -- Injected when relevant
   Feature histories, bug patterns, architectural decisions with WHY

LAYER 3: SEMANTIC MEMORY (cold)   -- Queryable on demand
   Full knowledge graph, all decisions ever, searchable via embeddings

Every competitor uses a flat file or single layer. We use the same architecture as human memory.

2. Auto-Generated Decision Logs (ADRs) Every architectural decision captured automatically with context:

Decision: Use Redis over Postgres for sessions
Date: 2026-03-10
Context: Scaling issues with session queries >10k users
Alternatives: Postgres JSONB, Memcached
Reason: Latency requirements, team Redis familiarity
Files affected: /auth/session.ts, /config/cache.ts

No existing tool does this. Manual ADR tools exist (adr-tools, Log4brains) but none auto-capture from AI conversations.

3. Team Sync via Git

cortex sync --team

• Memory commits to a shared branch
• New team member runs cortex init -> instant full project context
• Onboarding time: months -> hours
• No competitor has team-shared AI memory

4. Cross-Project Intelligence If you work on 5 projects, Cortex learns:

• Your personal coding patterns across all projects
• Mistakes you repeat
• Solutions from Project A that apply to Project B
• No competitor does cross-project learning

5. Visual Memory Browser (VSCode Sidebar)

• Every competitor is CLI-only or MCP-only (invisible)
• Cortex has a real UI: browse memories, pin/unpin, edit, see memory health
• Developers can SEE and TRUST what their AI remembers

• Solo developers using Claude Code (2M+ Cursor users, growing Claude Code base)
• Pain: Re-explaining context every session
• Value: "Claude remembers everything from yesterday"
• Price sensitivity: $9/mo is impulse buy

• Small teams (2-10 devs) using AI coding tools
• Pain: Onboarding new devs, knowledge silos, architecture drift
• Value: "New engineer gets context of a 2-year veteran on day one"
• Price sensitivity: $29/seat/mo justified by onboarding savings

• Engineering orgs (10-100+ devs)
• Pain: $7,500-$28,000 per hire onboarding cost, 3-9 months ramp
• Value: Cut onboarding time by 50%+, auto-generated ADRs for compliance
• Price sensitivity: $49/seat/mo trivial vs onboarding costs

The lock-in moat: After 6 months of Cortex, switching means losing your entire project brain. That's real retention.

[Activity Bar Icon: Brain]

CORTEX SIDEBAR
├── Working Memory (hot)
│   ├── Last session summary
│   ├── Current sprint context
│   └── Recent decisions (3)
├── Episodes (warm)
│   ├── Feature: Auth system (12 sessions)
│   ├── Bug: Memory leak fix (3 sessions)
│   └── Refactor: API layer (8 sessions)
├── Decisions (auto ADRs)
│   ├── Use Redis for sessions
│   ├── Switch to functional patterns
│   └── Drop microservices approach
├── Memory Health: 87/100
│   ├── Token budget: 743/800
│   ├── Stale warnings: 1
│   └── Last updated: 2 hours ago
└── [Search memories...]

Claude Code Session
    │
    ├── SessionStart hook ──> Cortex injects context into CLAUDE.md
    │
    ├── During session ──> Cortex tails JSONL, detects signals
    │   ("I decided to...", "The bug was...", file changes)
    │
    ├── PreCompact hook ──> Cortex extracts before context loss
    │
    └── SessionEnd hook ──> Cortex processes, updates all 3 layers
         │
         ├── Layer 1: Update working.md (~800 tokens)
         ├── Layer 2: Create/update episode in episodes/
         ├── Layer 3: Update knowledge graph + embeddings
         └── Auto-generate ADR if decision detected

Everything runs locally. No servers. No cloud. No privacy concerns. (Except Haiku API calls for extraction -- optional, can use local models as fallback)

Billing: License key validated in extension. Purchase on cortex website via Lemon Squeezy. VSCode Marketplace does not support paid extensions, so distribute free extension with premium features gated.

• VSCode extension scaffold with sidebar (TreeView)
• Claude Code hooks integration (SessionStart, PreCompact, SessionEnd)
• JSONL session file tailing and parsing
• Haiku API extraction (decisions, patterns, state summary)
• Auto-updating working.md injected into CLAUDE.md
• .cortex/ directory structure (working.md, episodes/, decisions.md)

• LanceDB + Transformers.js for semantic memory (Layer 3)
• Smart context injection (inject only what's relevant to today's changed files)
• Auto ADR generation from detected decisions
• Memory health score in sidebar
• cortex init and cortex status CLI commands

• Git-based team sync (cortex sync --team)
• Onboarding pack export (cortex export)
• Cross-project intelligence (personal patterns)
• License key gating for premium features
• Marketplace publishing (VSCode + Open VSX for Cursor)

• Landing page + Lemon Squeezy billing
• 60-second demo video (problem -> solution)
• Show HN post (Monday, link to GitHub)
• Reddit posts (r/ClaudeAI, r/SideProject, r/cursor)
• Discord community for beta users

Cortex: The memory your AI coding assistant should have had from day one.