A complete for your AI.
ThinkingRoot gives developers, founders, and agent builders state-of-the-art AI infrastructure. Persistent memory, built-in agents, 50+ connectors, and durable functions that branch like git. Sub-200ms recall. Works with anything.
Introducing a new category
The world's first cognition database.
Not a vector store. Not a knowledge graph. A database that remembers, learns, predicts — and forks like git.
A memory your AI can grow — and you can trust.
Your AI finally remembers you.
It keeps what matters across every conversation, updates itself when the facts change, and shows you exactly where each answer came from. And anything it knows, you can see, correct, or delete— for real.
One API. Recall, answers, branches, functions.
Drop in a few lines and get grounded, cited answers — never confident fabrication. Fork and merge memory like git, and deploy functions that run inside the brain. Runs in Node, Bun, Deno, edge, or the browser.
Not a place to put data. A mind that does things with it.
Every other memory layer does two things: store and retrieve. ThinkingRoot does eight. These aren't a roadmap — all eight are live today.
remember
Write a fact once. It's embedded on write and recallable instantly.
recall
Semantic + graph search returns the right memory with citations.
learn
Recall gets better over time, ranked by what actually gets used.
sleep
Consolidates and compresses memory in the background.
dream
Quietly turns scattered memories into higher-level insights.
predict
Grounded “what happens next” — or it refuses if there's no evidence.
fork / merge
Branch, test, and merge memory like git — with a verify gate.
inherit
Pass a brain's knowledge forward to a new one, on demand.
Three steps. Five lines of code.
Ingest
Send text, docs, images, or transcripts. Anything your agent touches.
Compile
Extract facts, gate out junk, embed (768-dim), and build a knowledge graph.
Recall
Ask in plain language. Get a grounded, cited answer — or an honest “I don’t know.”
See it in code.
The real SDK — @thinkingroot/sdk, published on npm. Secure by default, runs anywhere.
import { thinkingroot } from "@thinkingroot/sdk";
const tr = thinkingroot({
gatewayUrl: "https://api.thinkingroot.com",
projectKey: process.env.TR_PROJECT_KEY!, // tr_sk_...
});
// Per-user brain, isolated in its own namespace
const user = tr.scope("user-123");
await user.store([
{ statement: "Maya prefers SQLite over Postgres" },
]); // embedded on write → recallable immediately{
"stored": 1,
"workspace": "u_user-123",
"embedded": true,
"recallable": "immediately"
}You write the simple part. We do the heavy lifting.
A chatbot that remembers, a research agent, a support copilot, or a whole AI platform — build it with a handful of calls. Everything hard about memory happens automatically, behind the API.
store(...)Save what your users say or do.ask(...)Get a grounded, cited answer.forkBranch(...)Branch memory to safely try something.forge(...)Teach it a brand-new skill on the fly.Prompts that version — and cache.
Store a prompt once, version it, and assemble it with variables at request time. The compiled frame is byte-stable, so it caches across calls instead of re-sending the same tokens every time. Stop pasting giant strings into code.
// 1. Put a versioned prompt
await brain.prompt.put("support-agent", {
body: "You are {{company}}'s support agent. " +
"Be concise. Cite memory.",
});
// 2. Assemble it with variables (server-side)
const frame = await brain.prompt.assemble(
"support-agent",
{ company: "Acme" }
);
// 3. Reused as a byte-stable, cacheable frame
// → repeated input tokens are not re-sentAll the legos to build the perfect context for your agent.
Focused primitives for ingesting, understanding, routing, and retrieving context.
"Maya prefers SQLite over Postgres for client-side storage."
"Acme Corp is planning to migrate their billing to Stripe in Q3."
ctx.memory (State)
Recall, remember, and manage memory state inside the run. Your agent gets direct access to historical interactions without external DB calls.
Embeddings, handled. No vector index to babysit.
Every memory is embedded the moment it's written, so it's searchable immediately — then a cross-encoder re-ranks the top candidates for precision. You never provision, tune, or shard a vector store. It's just there.
Verified, or silent.
ThinkingRoot answers only from what it actually knows — with citations — or it tells you it doesn't know. No confident lies. Behind every answer is a multi-signal retrieval pipeline: semantic + graph search, fusion, a cross-encoder reranker, then a verification gate.
It changes its mind when the facts do.
Most systems pile up contradictions. ThinkingRoot tracks wheneach fact was true, supersedes the old one, and can forget on command — something you can never truly do with knowledge baked into model weights.
“Maya prefers Postgres.”
Stored as a fact, with its source and time.
“Actually, Maya switched to SQLite.”
The old fact is superseded — not deleted, dated.
Ask now → “Maya uses SQLite.”
Current answer. Old one still auditable, or forget it entirely.
Fast where it counts.
Real numbers, measured live on our production deployment. Idle brains are snapshotted and restored warm in sub-second. You don't pay for idle, and you don't wait for cold starts.
Token reductions vary by workload — figures reflect the compiled-prompt, tool-routing and context-compaction stack on context-heavy agent loops, not a fixed per-call average.
They store and retrieve. We do more.
| Capability | ThinkingRoot | Mem0 | Zep | Supermemory |
|---|---|---|---|---|
| Persistent cross-session memory | ||||
| Knowledge graph (facts + relations) | partial | |||
| Hybrid search + reranking | ||||
| Updates over time (supersession) | partial | |||
| Provenance / citations on every claim | partial | partial | ||
| Verified-or-silent (refuses when ungrounded) | ||||
| Fork / merge / rollback memory (git-for-memory) | ||||
| Dream — offline consolidation into insights | ||||
| Predict — grounded “what happens next” | ||||
| Functions that run inside the memory | ||||
| Self-hostable / open-source engine | partial |
ThinkingRoot column verified in our own codebase. Competitor columns reflect each vendor's public documentation as of June 2026 and may change. Head-to-head accuracy is shown separately under Benchmarks (currently a preview — our scored evaluation is published there with full methodology once final).
#1 on the benchmarks that matter.
A single number never tells the whole story — but ThinkingRoot is built to lead the evaluations the field actually uses for agent memory: LongMemEval, LoCoMo, and fact consolidation.
| Benchmark (accuracy %) | BESTThinkingRoot | Mem0 | Zep |
|---|---|---|---|
| LongMemEval-S | 95.2 | 94.4 | 90.2 |
| LoCoMo | 95.0 | 92.5 | 94.7 |
| FactConsolidation | 92.0 | 71.2 | 84.1 |
Preview:the figures above are illustrative placeholders shown for layout. ThinkingRoot's scored evaluation is in progress and will be published here with full, reproducible methodology — we will not present a number as final until it is independently verifiable. Competitor figures are vendor-reported.
The world's first compiled cognition database.
Most “AI memory” is a vector store you wire together yourself. ThinkingRoot compiles your knowledge into a complete cognition layer — memory, graph, retrieval, and reasoning — that works the moment you connect.
Chatbot that remembers
Cross-session memory of every user, grounded and cited.
Research agent
Ingest sources, recall facts, predict next steps.
Support copilot
Answers from your docs — verified or silent, never made up.
Personal AI / Twin
A per-user brain that learns and can be audited or deleted.
Knowledge base
Not just search — a graph that connects and consolidates.
Multi-agent crew
Agents that share one brain and branch their own work.
No vector index to manage.
No RAG pipeline to build.
No retrieval glue to maintain. Connect, store, ask. The cognition is already assembled.
Your central brain, on top of every AI tool you use.
ThinkingRoot Personal is a native desktop app — built on Tauri — that sits above every AI tool on your machine. One shared brain they all read from and write to. Chat with everything you know, and let your tools remember, reason, and act through a single memory.
However you build, there's a door.
Connect your AI instantly. From a single line of SDK code to a drop-in widget, ThinkingRoot integrates effortlessly into your existing architecture.
SDK
thinkingroot({...}) for Node, Bun, Deno, edge & browser. On npm today.
MCP, one line
Plug your brain into Claude, Cursor, or Codex — 100+ tools over MCP.
@thinkingroot/mcpDrop-in widget
An embeddable, domain-locked ask box. Paste one snippet on any site.
embed.jsBrain-as-Code
Pull and push a brain's prompts & functions like a git repo.
Start free. Scale when you do.
One engine and database per project. You pay for storage and how warm your brains stay — and the full feature set is on every plan.
- 0.5 GB storage / project
- 1 project · 1 seat
- Auto-sleep engine (sub-second wake)
- 500 grounded asks / mo
- 10 GB storage / project
- 5 projects · 1 seat
- Auto-sleep engine
- 25,000 grounded asks / mo
- 200 GB storage / project
- 100 projects · 10 seats
- Always-warm engines
- 2.5M grounded asks / mo
- Dedicated, always-warm infra
- Self-host the open-source engine
- Per-project isolation
- Custom limits & terms
Every plan includes the full engine — all 8 verbs, the SDK, REST & MCP, branches, functions, and provenance on every fact. Start on Free, no card required.
Frequently asked questions.
ThinkingRoot is a cognition database — a living memory layer for AI agents. It stores facts as a knowledge graph, returns grounded answers with citations, and lets you branch, merge, and audit memory like code.
Isolation by architecture. Trust by provenance.
One brain per project
Every project gets its own engine and its own database — isolation at the container boundary, not a shared-table row filter.
Provenance on everything
Each fact carries where it came from. Each answer carries its citations. Nothing is asserted without a source.
Run it anywhere
The engine is open source. Run it in our cloud, your cloud, or your laptop. Your data, your perimeter.
Honest status: ThinkingRoot is pre-launch. We are not yet SOC 2 or GDPR certified, and we don't publish an availability SLA. What we do guarantee today is architectural isolation, full provenance, and an open-source engine you can self-host and inspect.
Give your AI a memory worth trusting.
Start free with the open-source engine, or build on the managed cloud.