Private Beta · Design partners by invitation

Your AI agent doesn't
remember. It searches.

BrainCore is a local-first cognitive memory layer for AI coding agents. Built for dev teams who can't ship their code to cloud-RAG services.

Try the open-source version → See pricing
0.95
Retrieval R@5
4ms
P95 latency
0
Cloud calls
100%
Local by default
The Problem

RAG is not memory. It's Ctrl+F with embeddings.

Every "AI agent with memory" today does the same thing: chunk your data, embed it, dump it in a vector DB, return top-K by cosine. That's not memory. That's search. And it's why your agent confidently edits code based on chunks from branches deleted months ago.

PAIN 01
No structure
A decision becomes 3 chunks. The "why we chose JWT, what we rejected, what broke later" turns into disconnected fragments. The model glues them back — and invents the missing causality.
PAIN 02
No time
"We use Postgres" from 3 weeks ago and "We migrated to ClickHouse" from today both score high on cosine. Top-K returns both. The model picks the one that "sounds better." That's not memory — that's a coin flip.
PAIN 03
No "I don't know"
No vector RAG has a formal abstain mechanism. If retrieval is weak, the agent hallucinates with confidence. There's no architectural place for "I'm not sure — let's check first."
PAIN 04
No learning from failure
Yesterday's broken migration doesn't make it into the vector DB. The official docs do. Your agent learns from the official docs. Then breaks the migration the same way next week.
PAIN 05
No code identity
Rename a function, move a file — every memory linked to it breaks. The agent now has decisions about a function it can't find. Search returns stale chunks pointing to deleted paths. Refactoring poisons the memory.
PAIN 06
No privacy path
Every chunk of your codebase goes to a cloud RAG service. Healthcare, fintech, defense, regulated industries — they can't ship their code to OpenAI's vector DB. Local-first isn't a feature, it's a hard requirement.
The Architecture

Memory that thinks.

Nine typed memory layers, working together. Not bolted on — designed in from the schema up. This is what the difference between "search" and "cognition" actually looks like in production code.

LAYER 01
Atomic Knowledge Units
Every fact has truth_status, lifecycle, source_ref, confidence, valid_from / valid_until. Nothing flows to long-term memory without passing the gate.
LAYER 02
Strict Mode + Abstain
If retrieval evidence falls below threshold, the agent abstains and creates a brain task: "I need data for X to answer this." No silent hallucination.
LAYER 03
Causal Decision Chains
Decisions are stored as problem → alternatives → choice → reasoning → outcome. Six months later you can ask "why JWT?" and get the actual reasoning back, not three chunks.
LAYER 04
AST-based Code Identity
Code symbols identified by structural hash, not file path. Rename a function — links don't break. Refactor — past decisions stay attached to the new location.
LAYER 05
Internal Git Versioning
Every memory change is a commit. Time-travel queries: "what did I know about this code 30 days ago?" Branch isolation: feature-branch memory doesn't pollute main.
LAYER 06
Memory Scoring
Composite score from importance × trust × usage × recency × stability − risk − noise. Important knowledge surfaces. Noise decays automatically. Like a real brain.
LAYER 07
Negative Memory + Rule Engine
Past failures stored as first-class entities with linked tests. Pre-edit rule engine blocks patches that would repeat known mistakes. Your agent learns from being wrong.
LAYER 08
Context Firewall
Sits between tools and the LLM. Compresses raw outputs (logs, diffs, grep results), enforces token budgets, stores raw separately by reference. The agent gets clean signal — never the 50K token noise dump.
LAYER 09
Truth Verification
Every LLM-extracted claim goes through evidence checking against memory before promotion. Source/trust/confidence gates. Rejected hypotheses are kept — so the same wrong claim doesn't re-enter as new.
Versus Other Memory Tools

Built where they can't follow.

Mem0, Letta, Zep — all great teams, all built around the same architectural assumption: cloud-first vector retrieval. We start from a different premise: cognition is local, structured, and capable of saying "no."

Feature BrainCore Generic vector RAG memory tools
Local-first by default ✓ Yes ✗ Cloud-first, self-host as opt-in
Strict abstain mechanism ✓ First-class outcome ✗ No formal gate
Causal decision chains ✓ problem→alt→reasoning→outcome ✗ Flat text storage
Negative memory (failures) ✓ First-class with linked tests ✗ Not in schema
AST-based code identity ✓ Survives refactors ✗ String-based, breaks on rename
Self-model (competencies, blind spots) ✓ Built in ✗ Not modeled
Privacy-conscious deployment ✓ SOC 2 path, on-prem, air-gap ✗ Cloud-API tied
The Numbers

Built and benchmarked.

Real benchmarks on the open-source predecessor, total-agent-memory (v10.5, 27 stars, 9 IDEs supported). Same retrieval architecture powers BrainCore beta. Reproducible — run the bench yourself.

0.95R@5
Retrieval recall, gate threshold 0.85
on internal evaluation set
4ms
P95 retrieval latency
25× headroom under 100ms gate
19/20
Bench scenarios passing
Plus 11/11 legacy migration tests
370
Unit tests in CI gate
Every release blocks on green
Pricing

Free for one. Honest for teams.

Run BrainCore on your own laptop forever, no questions, no telemetry. When your team scales, scale with us — pricing built for dev teams, not for VCs.

PERSONAL
Free forever
Solo developers running locally
  • 1 user, full local install
  • Full local memory engine
  • Strict mode + abstain
  • Local dashboard (3D graph)
  • Community support
Install free
PRO PERSONAL
On launch
Power users wanting cloud sync
  • Everything in Personal
  • Encrypted cloud backup
  • Multi-device sync
  • Priority email support
  • Early access to new features
Join waitlist
TEAM
On launch
Dev teams 2–10 engineers
  • Shared team memory pool
  • Team analytics dashboard
  • Branch-aware memory
  • Shared decision history
  • Slack integration
Apply
BUSINESS
On launch
Growing teams 11–50 engineers
  • Everything in Team
  • SSO (SAML, OIDC)
  • Audit log & RBAC
  • Priority support SLA
  • Custom retention policies
Contact sales
ENTERPRISE
Custom
50+ teams, regulated industries
  • Everything in Business
  • On-prem / air-gap deployment
  • SOC 2 compliance path
  • Dedicated success manager
  • Custom SLA & support
Contact sales

Personal tier ships in beta now (May 2026). Other tiers launch Q3 2026. Design partners get early access during beta. Pricing details published at launch.

From the Founder

Why I'm building this.

I'm a senior full-stack engineer with 15 years of shipping production code. The last 6 months I've been deep in AI agents — Claude Code, Cursor, Codex, MCP servers, every memory framework I could find.

I built BrainCore because I personally lost dozens of hours debugging agents that confidently edited code based on data from branches deleted months earlier. Every memory framework I tried had the same architectural problem: vector similarity is not cognition.

BrainCore is the answer I wish existed when I started. Local-first because privacy matters. Strict-mode because honesty matters. Cognitive layers because the difference between "search" and "memory" is the difference between an intern with confidence and a senior engineer who knows when to ask.

If you're building AI products and you're tired of agents that lie to you with a straight face — let's talk.

Vitalii Cherepanov · Founder, BrainCore
LinkedIn · GitHub
Apply for Beta Access

Ship code your agent actually remembers.

BrainCore is in private beta. We're onboarding 5–10 design partners through May 2026 from privacy-conscious dev teams in healthcare, fintech, and AI/ML startups. Open-source predecessor is fully public — try it today while we open BrainCore to design partners.

Apply for design partner → Try open-source version

Source code currently private during beta. Read access available to evaluation partners on request.