Plug-and-playmemory for your AI
ThinkingRoot gives your AI product or agent a memory that grows. Drop it in with a few lines of code — it remembers every conversation, understands context, and keeps a private, persistent memory for every user.
✦ Your AI finally remembers the people who use it. ✨
Growing long-term and short-term memory — private to each user, persistent, and grounded. Out of the box.
State-of-the-art research foundation
Connect once. Memory stays.
Bring sources from the tools you already use. ThinkingRoot compiles them into durable, cited memory for every user.
SDK, MCP, REST, or CLI — one project key.
Connectors, files, and URLs through one funnel.
Verified facts into a private brain per user.
Cited answers in ~72ms. Silent when unsure.
- Private memory per user — not a shared store filtered by ID
- Byte-exact citations on every stored fact
- Same API over SDK, MCP, REST, and CLI
Two platforms built on the same engine
Grounded, cited, and durable active mind database that learns from user context.
A secure, private personal AI mind that keeps track of your notes, thoughts, and files.
RAG reads. Compiled Augmented Generation understands.
Read paperRetrieval-Augmented Generation makes the model read, count, and reconcile raw chunks on every query. Compile-Augmented Generation does the hard work once — compiling knowledge into a verified, byte-anchored graph — so answers are computed, current, and cite the exact source.
Understanding, compiled once.
Query-time reading, every time.
The hard reasoning happens once, at ingest — not on every query.
Counts, sums, and dates are computed in Rust. The model never does math.
Every fact traces to an exact source range, re-verified with a BLAKE3 hash.
Bi-temporal facts — superseded info is surfaced, not served.
ThinkingRoot gives a mind to you and your app's users. An AI product that truly knows its users is one they keep coming back to.
Join waitlistSpot agent creation inside console or through SDK
Read agents docConfigure, deploy, and monitor agents with leading Thinkingroot engine accuracy and ultra-low latency across chat—with the persistence of forkable and mergeable Git-like branches as the brain for agents.
Chat with your agents directly over your fact-graphs. Unauthenticated sessions persist securely using a unique browser-level client ID.
Compile documents into active memory, embed agents with one line of code, and monitor sessions in real-time.
Integrate databases, private APIs, and raw file repositories as live, active sources of truth for agent cognition.
Enforce strict compliance and behavioral boundaries, guaranteeing all agent outputs are grounded and align with policy.
Fork agent memory and configurations into parallel Git-like branches to test updates safely before merging changes.
ThinkingAgent goes beyond simple prompt replies to execute complex workflows. Fork configurations, test updates in isolation, and run agents that actually understand context.
Join waitlistOr build anything on the mind — SDK, MCP, and REST
One line gives your app a mind. Runs everywhere JavaScript does — Node, Bun, Deno, edge, and the browser. Secure by default, scoped per user.
import { thinkingroot } from "@thinkingroot/sdk"; const tr = thinkingroot({ projectKey: TR_KEY });const user = tr.scope(userId); await user.remember("Maya moved her DB to Neon.");const { answer, cites } = await user.ask( "What DB does Maya use?");One URL plugs your mind into any AI tool — no glue code. Your agent can remember, recall, and ask, right inside the editor.
Every primitive over plain HTTP — call the mind from any language or runtime. Streaming answers, 429-safe, one bearer key.
curl https://api.thinkingroot.com/ask \ -H "Authorization: Bearer tr_sk_…" \ -d '{ "query": "What did Maya decide?", "user": "u_123" }'export default rootFunction(async (ctx) => { // 1. Recall facts directly from memory const facts = await ctx.memory.recall("open tickets"); // 2. Dynamically acquire the required skill const skill = await ctx.acquire("summarize-thread"); // 3. Schedule self-run in 1 hour (durable execution) await ctx.scheduleSelf({ in: "1h" }); return skill.run(facts);});Durable code + cacheable prompts.
Move beyond static LLM parameters. Run calculations, trigger scripts, and structure templates directly co-located with memory.
- Durable execution — built-in timers, retries, and idempotency
- Zero latency — co-located with the memory graph
- Self-extending — dynamically acquire or forge new skills on demand
More than memory — it acts.
The Mind doesn’t just remember. It routes to the right skill, orchestrates multi-step work, and acts inside your users’ apps.
Act in 50+ apps — Gmail, Slack, GitHub, Notion — with per-user OAuth, so the Mind works on your users' behalf.
Just-in-time route-or-forge: it picks the right function for a task, or builds a new one on the fly.
Compose multi-step flows — fan out to a crew, gather results, and branch — all backed by durable memory.
State of the art — and 85% lighter
CompAG compiles understanding ahead of time, so every query ships ~2K tokens of verified facts instead of stuffing raw context. You spend far fewer tokens for grounded, cited answers — and the no-leak accuracy eval publishes soon.
Lower is better · measured vs typical RAG context · full methodology in the paper
The wins are architectural, not prompt-tuning. LongMemEval (no-leak) results publish with the paper.
Read the paper| RAG | Zep / Graphiti | ThinkingRoot | |
|---|---|---|---|
| Understanding happens | Query time | Ingest + query | Compile time |
| Counts, sums, dates | LLM guesses | LLM guesses | Computed in Rust |
| Provenance | A document | Node / edge | Exact bytes, verified |
| Wrong-count failures | Common | Common | Impossible |
Best for latency, quality, and cost.
The hard work happens at compile time — so at query time you get faster answers, grounded in proof, for a fraction of the tokens.
Answers in the blink of an eye.
- Sub-200ms hybrid recall
- Answer cache for instant repeats
- Compiled prompts — repeated tokens never re-sent
Grounded, current, and provable.
- Cited answers — verified, or it stays silent
- Fact-quality gate + verification
- Supersession — it changes its mind when the facts do
- A knowledge graph, not raw chunks
A fraction of the tokens.
- −85% input tokens per query
- Byte-stable prompt frames → cache-friendly
- Compile once — never re-read the same source
You’ve posted about this.
The walls every AI builder keeps hitting — and how ThinkingRoot answers each. Real problems, real sources.
My agent forgets everyone the moment they close the tab.
A per-user mind that persists across sessions.
RAG cites a source that doesn't actually support the claim.
Every fact is byte-anchored and re-verified — cited, or silent.
I re-send the whole history every call and the bill explodes.
Ship ~2K verified tokens, not the raw dump — up to 85% fewer.
A user asked to be deleted — stale embeddings still linger.
Verifiable delete: the fact and every answer that used it.
Per-user OAuth for every app is a whole backend to build.
A broker handles it — your agent just acts in Gmail, Slack, GitHub.
My agent dies halfway and re-runs side effects on retry.
Durable Root Functions resume from checkpoint — no re-runs.
Plug-and-play memory, compared.
How ThinkingRoot stacks up against mem0, Zep, and Supermemory — honest, cell by cell. Where a competitor does it too, we say so.
Based on each product’s public documentation, July 2026. Spot something wrong? Tell the founder— we’ll correct it.
Questions, answered honestly.
Every claim on this site is measured or labeled as pending. Same rule here.
How is ThinkingRoot different from mem0 or a vector database?
Most memory layers are one shared store filtered by a user ID, returning raw chunks for the model to re-read. ThinkingRoot compiles knowledge into verified facts and gives every user their own isolated database — with git-like fork/merge, cited answers, and durable functions living inside the memory.
What's your benchmark score?
We're running LongMemEval against the real production path right now, and we'll publish the number — including anything unflattering — before claiming any ranking. What's already measured: ~72ms recall and byte-exact source grounding on every stored fact.
Can one user's data leak into another user's answers?
No. Isolation is architectural, not a filter: each user's memory is a separate database, every request is scoped at the gateway, and embed tokens pin a single user. There is no shared table for data to cross.
Does it lock me into a model or a cloud?
No. ThinkingRoot works over SDK, REST, and MCP with any model or framework. Your users' memory isn't trapped inside one vendor's stack.
What can it ingest?
Text, PDF, Word, PowerPoint, Excel, CSV, JSON, images (captions + OCR), audio (transcription), and URLs — with Notion, Slack, and Gmail connectors arriving at launch. Everything flows through the same compile funnel.
How much does it cost?
Free tier to start, usage-based credits as you grow. Selected builders from the waitlist get 3 months of credits.
Why not just build this in-house?
You can — most teams spend a quarter wiring a vector DB, an extractor, and per-user isolation, and MIT's 2025 GenAI study found in-house pipelines succeed about a third of the time. ThinkingRoot is a few lines of code: try it in an afternoon before betting a quarter on it.
From the blog
Bring everything you have.
We'll do the thinking and the rooting.
Ingest any document, database, or API. ThinkingRoot compiles it into a growing, private memory for every user of your AI.
Selected builders get 3 months of credits.