Teach the field
Run /expand on a subject and FaultLine learns it to real depth from online sources — with its own anti-sprawl bounding, so it maps the field, not the whole world.
The problem
Your AI forgets who you are.
Every new chat starts from zero — so the usual fix is to re-stuff the entire conversation history, or a pile of fuzzy RAG chunks, back into the model on every turn and hope the detail that matters is somewhere in the pile. It works, sort of. It also costs you three ways at once.
- It burns tokensYou pay to re-send the same haystack, turn after turn, just to remind the model what it already heard.
- It adds latencyMore context to ship and to read means a slower reply on every single message.
- It hallucinates deeperThe longer and deeper the context grows, the worse a model gets at finding the needle — so accuracy quietly erodes.
The first win · lower cost
Send the model one true fact — not a haystack.
So here’s the first thing that changes. Traditional memory and RAG stuff the whole conversation history, or a pile of fuzzy retrieved chunks, into the model's context window every single turn. It's expensive in tokens, it's slower, and accuracy degrades the longer and deeper the context gets. FaultLine returns the precise, grounded fact — nothing else.
Everyone else
Dump 40k tokens of history and hope.
Re-send the transcript, or a bag of similar-looking chunks, on every turn — and trust the model to find the needle. More tokens, more latency, more chances to drift. (Illustrative — the exact size depends on your conversation.)
FaultLine
Return the one true fact.
A deterministic walk hands back exactly the grounded fact the question needs — traceable to a real row. The model reads a sentence, not a haystack.
- Less contextone scoped fact, not the whole transcript
- Lower token costyou pay for a sentence, not a haystack
- Lower latencyless to send, less to read
- Better accuracyno long-context degradation to fight
For agents, where tokens are literally money and long-context degradation is a real failure mode, sending one grounded fact instead of a transcript is a direct, per-turn bottom-line win.
Why it’s different
Memory you can actually trust
Both of those wins rest on the same foundation: a validated graph instead of a fuzzy vector store. Here’s what that grounded foundation gives your AI.
Truth you can trace
Every write passes a validation gate and every recall is a deterministic walk of real rows — so your AI answers from a fact it can point to, not a cosine guess. If it isn’t there, it says so instead of inventing one.
Never locked to one model
Speak the Model Context Protocol and you’re connected — so you can wire it to Claude today and swap models tomorrow while the same validated memory travels with you. The model is interchangeable; the memory is authoritative and yours.
Memory that’s actually yours
A schema per tenant, physically separable — so you can export it, delete it, or point it at your own endpoint anytime. Privacy-first and sovereign, hosted in Canada 🍁. No training on your memory, ever.
It never bluffs
A hard line between what you told it and what it merely inferred — so stated facts come back asserted with confidence, and guesses come back flagged as tentative. It never dresses an inference up as a fact.
Your agent gets its own memory
Beyond your memory, the serving agent keeps its own private, operational memory — so it remembers what worked, what failed, and how to do it next time. It’s walled off from your data and never mixed in. An engineer’s notebook, not “the AI has feelings.”
One engine, two markets
Built for people and for agents
The same validated memory substrate serves a private personal memory and a production-grade agent memory. Pick your side.
A memory that follows you
A private memory that carries across every AI chat you have. It remembers your life, your people, and your preferences — and surfaces them exactly when they're relevant, not as a wall of context.
- Remembers your people, dates, and preferences — grounded, correctable, yours
- Works across models — switch AIs, keep your memory
- Correct it in plain language — you are the source of truth
- Export or purge anytime — sovereign by default
Drop-in memory for AI agents
Validated long-term memory for your agents over MCP — grounded, per-tenant isolated, and temporally aware, so it tracks how facts change over time instead of stacking contradictions. A serious, self-serve alternative to Mem0 and Zep.
- MCP-native — remember / recall / retract as tools
- Its own operational memory — firewalled from user memory, never mixed
- Lean context — one grounded fact, not a 40k-token dump
- Temporally aware — valid-time and belief-time, kept orthogonal
- Per-tenant isolation — schema-per-tenant, no cross-talk
- Deterministic recall — traceable rows, not vector roulette
See the Agent plan ▸
Self-serve, prices published — no sales call to get started.
How it works
Strong ingest. Deterministic recall.
No magic — just where the work happens. All the intelligence is spent at write time — extraction, validation, classification. Recall is a plain, fast walk of the structure that ingest laid down. Every answer traces back to a real row.
Remember
You — or your agent — state something. FaultLine parses it into grounded entities and relationships: who, what, when, and how they connect.
Validate
Each fact passes the write gate: typed against an ontology, classified by provenance, checked for conflicts and corrections. Stated truth is grounded; inferences are held apart.
Recall
A deterministic walk of the graph returns the real facts, scoped to your question — delivered over MCP to whatever model you're talking to. No fuzz, fully traceable.
The honest comparison
Great company. Go try them.
The AI-memory field is full of genuinely excellent work, and you should evaluate it. Here's an honest read on the leaders — what each does well, and where FaultLine is different.
Our position, plainly: Zep and Mem0 do excellent work — go try them. If you want memory you can prove, own, and run per-tenant, that's the difference. We respect the field; we just draw a harder line between what was stated and what was guessed.
Mem0
mem0.ai ↗The quickest way to add a memory layer to an app, with a huge community and dead-simple developer experience. Vector-first, generous free tier (~10k memories), from $19/mo, with graph memory on the $249/mo Pro plan. If you want to ship memory today, Mem0 is a superb choice.
FaultLine differs: validated, grounded writes — no fuzzy vector guessing — plus per-tenant schema isolation you own.
Zep (Graphiti)
getzep.com ↗Zep pioneered the temporal knowledge graph with its open-source Graphiti engine, tracking facts as they change over time with validity windows. It scores a genuinely excellent 63.8% on LongMemEval (vs Mem0's 49%). Flex plans from $125/mo. This is serious, well-engineered memory.
FaultLine differs: the same temporal-graph strength plus validated writes, the stated-vs-inferred epistemic firewall, and schema-per-tenant isolation.
Letta (MemGPT)
letta.com ↗Letta (formerly MemGPT) is a full agent runtime with OS-style self-managed memory and a strong research pedigree — and it's self-hostable. If you want an opinionated agent operating system with memory baked in, Letta is excellent.
FaultLine differs: we're model-agnostic memory infrastructure over MCP — run us under any runtime, including theirs.
Supermemory
supermemory.ai ↗Supermemory shines at multi-source ingestion for personal knowledge management — tweets, web pages, documents — with a generous free tier. If your goal is a personal second brain that ingests everything, it's a great pick.
FaultLine differs: built for provable, owned, per-tenant memory — personal and agent, one engine.
Per-tenant isolation
A dedicated schema per tenant. Your data is physically separable — no shared table, no cross-talk.
Canadian-hosted 🍁
Sovereign infrastructure. Privacy-first — we never train on your memory.
Your data is yours
Export the whole graph or delete it on demand. Point the engine at your own model endpoint.
Validated writes only
No unsupervised model writes — every fact passes the gate. The truth lives in the memory, not the model.
Transparent pricing
One seat, three prices — the base buys it down.
The monthly base fee is the tenant portal / control layer — seats, logins, MFA, dashboards, oversight — and it also buys every seat down. Individual pays retail with no base, Team ($750/mo base) less, Enterprise ($1,500/mo base) least. Every number's below, in CAD, billed monthly, cancel anytime. The only "talk to us" is genuinely bespoke (on-prem, regulated, custom isolation). See the full side-by-side matrix ▸
Individual — one person, no base, retail per seat
First month free · Standard $15 · Advanced $40 · Expert $60 · Agent $120.
The foundation —
No portal, no base — pay retail for the one seat you use, and the first month is free. Same four seat types as every tier; committing a Team or Enterprise base is what buys them cheaper.
- Personal validated memory for one person
- Grounded, deterministic recall across every model
- Any seat type — export & purge anytime
Standard
$15/ mo
Personal memory for everyday AI chats.
Advanced
$40/ mo
Bigger memory + own-endpoint control.
Expert
$60/ mo
High quota, priority recall, power features.
Agent
$120/ mo
Agent memory + agent voice for devs.
First month free on every Individual seat — start on the seat type you want, pay only from month two. Agent solo is $120, and it drops to $100 on Team / $80 on Enterprise.
Team — $750/mo base + cheaper seats, up to 15
Base = tenant portal + 2 Standard seats · seats $12.50–$100 · up to 15 total.
Everything in Individual, plus —
Outgrew solo, but you're not an enterprise? This is your tier. The $750/mo base is your tenant portal — seat management, logins, MFA, dashboards, oversight — with 2 Standard seats included, and it buys every added seat down to the Team rate. The affordable bridge, so you never jump from solo straight to the enterprise base.
- Tenant portal & seat control — logins, MFA, dashboards, memory oversight
- 2 Standard seats included in the base
- Mixed seat types, up to 15 seats
Team base
$750/ mo base — the tenant portal + 2 Standard seats
Your control layer for seats, logins, MFA and memory oversight — and it buys every seat down to the Team rates below. Add up to 15 seats total.
Add seats above the included two — any type, at the bought-down Team rate:
Standard
$12.50/ seat / mo
Core validated memory per teammate.
Advanced
$35/ seat / mo
Bigger memory + own-endpoint control.
Expert
$50/ seat / mo
High quota, priority recall, power features.
Agent
$100/ seat / mo
Agent memory + agent voice for your builders.
Need more than 15 seats? That's Enterprise — a bigger base, and the seats drop again.
Enterprise — $1,500/mo base + the cheapest seats, unlimited
Base = portal + 5 Standard + SSO/isolation/SLA/compliance · seats $10–$80 · unlimited.
Everything in Team, plus —
The $1,500/mo base is the tenant portal with 5 Standard seats included and the enterprise controls — and it buys every seat down to the lowest rates on the page.
- Unlimited seats
- SSO
- Dedicated isolation
- SLA
- Compliance controls
- Support
Enterprise base
$1,500/ mo base — the tenant portal + 5 Standard seats
SSO, dedicated isolation, SLA, compliance controls, and support on the same validated engine — and the deepest seat buy-down. Bring your own model brain; we host the memory.
Add unlimited seats above the included five — any type, at the lowest per-seat rates on the page:
Standard
$10/ seat / mo
Core validated memory per teammate.
Advanced
$30/ seat / mo
Bigger memory + own-endpoint control.
Expert
$45/ seat / mo
High quota, priority recall, power features.
Agent
$80/ seat / mo
Agent memory + agent voice — lowest Agent rate.
Custom — the only "talk to us"
That's our full price list above. Need something we don't list — on-prem, regulated / PHIPA, or custom isolation? Talk to us and we'll build it.
Give your AI a memory it can prove.
Start free — first month on us. Grounded, validated, and yours, across every model you use.
FAQ
Straight answers
The questions people actually ask about FaultLine — answered plainly.
What is FaultLine?
FaultLine is a validated knowledge-graph memory for AI. It extracts entities and relationships from what a user or agent states, validates each write against an ontology, and stores grounded, traceable facts in a PostgreSQL-authoritative graph. Recall is a deterministic walk of those real rows rather than a fuzzy vector-similarity match — so every answer traces back to a fact that was actually stored. It is model-agnostic and connects over the Model Context Protocol (MCP).
How is FaultLine different from Mem0 or Zep?
Mem0 and Zep are both excellent — go try them. Mem0 is the fastest bolt-on vector-first layer; Zep pioneered the temporal knowledge graph and scores 63.8% on LongMemEval. FaultLine's difference is validated, grounded writes and deterministic recall (no fuzzy guessing), a strict epistemic firewall between stated facts and inferences, and per-tenant schema isolation you own.
Is my memory private?
Yes. Each tenant gets a dedicated, physically separable PostgreSQL schema — no shared table, no cross-talk. FaultLine is Canadian-hosted 🍁, never trains on your memory, and lets you export the entire graph or delete it on demand. No model gets unsupervised write access; every fact passes the validation gate first.
Does it work with Claude?
Yes. FaultLine is model-agnostic and speaks the Model Context Protocol (MCP), so it connects to Claude and any other model or agent runtime that speaks MCP. It exposes remember, recall, and retract as tools. Switch models whenever you like and keep the same validated memory.
How much does it cost?
One seat, three prices — the monthly base is the tenant portal and it buys every seat down. Individual (no base, first month free): Standard $15, Advanced $40, Expert $60, Agent $120. Team ($750/mo base = portal + 2 Standard seats, up to 15): seats $12.50 / $35 / $50 / $100. Enterprise ($1,500/mo base = portal + 5 Standard + SSO, isolation, SLA, compliance, unlimited seats): seats $10 / $30 / $45 / $80. The same seat costs less the more base you commit. Custom on-prem / regulated builds are the only talk-to-us option. Prices in CAD.
Why deterministic recall over vector similarity?
A vector store returns the nearest fuzzy match, which can surface something that sounds related but isn't what was said. FaultLine spends its intelligence at write time — extraction, validation, classification — then recalls by walking the graph it built, returning real facts scoped to the question. If a fact was never stored, it says so instead of inventing one. That's how it avoids hallucinated memories.
Does FaultLine cut token & context costs?
Yes. Traditional memory and RAG re-send the whole conversation history — or a pile of fuzzy retrieved chunks — into the context window every turn: expensive, slower, and less accurate as context grows. FaultLine returns the one grounded fact the question needs via a deterministic walk, so you send the model a sentence, not a haystack. Less context, lower token cost, lower latency, better accuracy — a direct win for agents, where tokens are money and long-context degradation is real.
Can I teach it an entire subject?
Yes. Beyond the memory it builds automatically around what you tell it, /expand (a.k.a. /learn) has FaultLine learn a whole domain — networking, law, medicine — to real depth from online sources, growing the structured hierarchy with its own anti-sprawl bounding. Once the field is in place, everything you state later lands where it belongs and is walkable. Train once, serve forever — most memory tools store only what you feed them.
Does my agent get its own memory?
Yes. Beyond the user's memory, a serving agent keeps its own private, firewalled operational memory — its lessons: what worked, what failed, the gotchas, how to do it next time. It's completely walled off from the user's memory; the two never mix. This is operational memory for the agent's own work — not a claim that the AI has feelings.