Make your AI product
Understand User
ThinkingRoot is growing AI infrastructure that gives every user their own mind — one that thinks, remembers, and acts. In a few lines of code.
A living mind for every user
It remembers, learns, and grows with everyone who uses your app — grounded, cited, and yours to fork.
Deploy agents that remember every user, inherit a shared brain, and take real action.
Durable functions that run inside the brain.
State-of-the-art research foundation
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" }'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
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);});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
Best for latency, quality and cost.
Or configurable for each use case.
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.
From the blog
Bring everything you have.
We'll do the thinking and the rooting.
Ingest any document, database, or API. ThinkingRoot compiles raw text into a secure, content-addressed memory layer for your AI agents.