GBrain, reviewed: what it does well and what it skips

Every night while Garry Tan sleeps, an AI agent reads his meetings, emails, and tweets, files them into a knowledge base, and rewires the links between them. He wakes up to a brain that got a little smarter overnight. Tan is the CEO of Y Combinator, and the system is called GBrain.

He open-sourced it in April 2026, days after AI researcher Andrej Karpathy seeded the idea publicly.

GBrain became the reference design for the whole company brain movement. It crossed 5,000 GitHub stars in a day and sits near 24,000 today.

We spent a few days reading every line of it. The engineering is genuinely good, although it skips one important part:

GBrain's overnight maintenance keeps the brain organized. It does almost nothing to keep it true.

That gap, between tidy and trustworthy, is the most interesting thing about it. It is also the problem we think about every day at Slite.

Key takeaways:

• GBrain is an open-source AI memory system: a self-maintaining markdown knowledge base with a typed knowledge graph on top.
• Its real strengths are continuous ingestion and an overnight dream cycle that keeps pages fresh and well-linked.
• It builds its knowledge graph with zero model calls, so ingestion and overnight maintenance are cheap. The real cost is querying the brain.
• It is built for one person: no real permission model, and it reads mostly local data rather than team-wide tools.
• It keeps a brain organized, but it does not verify the brain is correct or complete. That is the open problem for the category.

What is GBrain?

GBrain is an open-source AI memory system created by Garry Tan, CEO of Y Combinator. It is a markdown knowledge base backed by Postgres that ingests signals like meetings, emails, and messages, stores them as pages, and maintains a typed knowledge graph of people, companies, and projects. It updates itself on a nightly schedule. Because it is built around one person's data on one machine, GBrain is most often compared against team-oriented company brain tools and agent memory layers.

Tan built GBrain in about twelve days and released it under an MIT license on GitHub. It runs the knowledge layer behind his own agent setups.

By his own numbers, his production brain holds 146,646 pages, 24,585 people, and 5,339 companies, maintained by 66 scheduled jobs. Those are his figures, not an independent audit, so treat them as a sign of scale rather than a benchmark.

The reason it caught on is the promise in one line from Tan: "I wake up smarter than when I went to bed, and so will you." For anyone who has watched a wiki rot, that is a strong pitch.

The underlying idea, an LLM that builds and maintains its own knowledge base, predates GBrain. GBrain is the most-copied implementation of it. Other teams have shipped their own take, like how Cerebras built its internal knowledge base.

How does GBrain actually work?

Underneath the markdown, GBrain is four layers stacked together: a file store, a search engine, a knowledge graph, and a set of skills that do the work.

The repository: plain markdown files

At the core, GBrain is a folder of markdown files, one per entity or topic. Instead of documents you write, the files hold what the system knows about a person, a company, a deal, or a meeting. The agent writes them. You mostly read them.

Retrieval: hybrid search

Search combines keyword and semantic matching, so results hold up on both exact terms and fuzzy questions. GBrain runs vector similarity, BM25 keyword matching, and a reranking step on top. It is close to the approach we use in our own search, and it is the right first step.

The knowledge graph: typed, fixed, and built without a model

GBrain links entities with a fixed set of typed relationships, and it does it without calling a language model. Relationships like works-at, founded, invested-in, and attended are extracted with plain pattern matching. That keeps writes fast and nearly free.

The trade-off is rigidity. The vocabulary is hardcoded, so the graph only recognizes the relationship types it was taught. On Tan's own benchmark, a 240-page corpus, turning the graph on lifted precision@5 from about 18% to 49%, a 31-point gain. That is his test on his own data, which makes it promising rather than proven.

Skills: the always-on detector and the overnight crew

The real intelligence lives in skills, small markdown workflows the system runs on triggers. One skill watches every incoming signal and decides, with a cheap model, whether anything in the brain should change.

A router GBrain calls the resolver then sends each change to the right specialist skill, like fixing a citation. Other skills run overnight on a schedule.

What happens overnight? The dream cycle

Once a day, GBrain runs a maintenance pass it calls the dream cycle, which cleans, links, and re-synthesizes the whole brain.

It runs roughly eight to nine phases, depending on the version:

• lint and fix,
• repair backlinks,
• sync,
• synthesize new pages from raw transcripts,
• extract entities,
• find patterns across sessions,
• re-embed stale content,
• and report orphans.

In plain terms, it removes stale pages, fixes broken links, re-files things, and writes fresh summaries.

During synthesis it follows strict rules: quote sources verbatim, cross-reference everything, and never silently overwrite a page.

Does the dream cycle check whether your brain is true?

No. GBrain's overnight maintenance organizes and refreshes a knowledge base. It removes stale and orphaned pages, repairs links, and re-synthesizes summaries, but it does not fact-check the content or confirm the knowledge is accurate or complete.

A tidy brain looks like a trustworthy one, which is what makes the gap easy to miss.

The dream cycle gives you a clean index, healthy backlinks, and no dead pages.

None of that tells you whether what a page says is still correct, which is exactly where stale documentation does its quiet damage. Even orphan removal is left as a report for a human to judge, not an automatic delete.

We have felt this tension first-hand. For the first time, the organizing work of a knowledge base can be automated. That still does not guarantee the result is complete or right.

The people building these systems feel it too.

One founder who runs seven internal AI agents on a single Mac Mini told us his memory layer started hitting scaling limits within weeks. An engineer who rebuilt his team's knowledge as a local wiki put it more bluntly: GBrain, to him, felt "way too focused on single player."

What does an agent AI memory layer like GBrain cost?

Running a GBrain-style memory layer costs roughly $4 per user per month for a small team and $8 to $15 per user per month with heavier use. Ingestion and overnight maintenance are close to free, because the system barely reprocesses the data it stores. The main cost is querying the brain.

The cost depends far less on what you feed the brain than on how often you query it.

Ingestion and maintenance are the cheap parts.

Because the graph is built without model calls, writing and reorganizing pages costs almost nothing. Embeddings run around $0.10 to $0.13 per million tokens, and re-indexing a 100-million-token corpus costs about $13.

The overnight maintenance keeps the index tidy without reprocessing the underlying data, so it adds very little.

What does add up is querying.

GBrain answers from the brain first, then calls a model to expand and run each search, so the bill tracks how often people ask it questions, not how much it takes in.

Those figures assume OpenAI embeddings plus a Claude-class model handling query expansion and reranking on every question.

The $4 end is a handful of searches per user per day; the $8-to-15 end is heavy, all-day querying. Change the model or the query volume and the number moves with it.

Most people run GBrain through a Claude or Codex subscription they already pay for, so those per-query calls feel free even though they are not.

That is part of why GBrain is such a good fit for individual, personal use, where one motivated person absorbs both the cost and the setup.

A company brain like this is cheap to build and keep current. What you pay for is querying it.

GBrain alternatives

GBrain is a personal brain: one person's markdown files, on one person's machine, maintained overnight. It has no shared store, no permission model, and no memory of the conversations an agent has along the way.

Each of those gaps has a tool built around filling it.

Slite - a dedicated company brain

GBrain asks one motivated person to stand the system up and keep it running. In a company a managed company brain trades that control for upkeep you do not own.

GBrain's dream cycle keeps the brain tidy and well-linked, but it never asks whether a page is still true.

Slite Agent fact-checks documents against live activity across more than 20 connected sources, then routes each suggested update to a human triage queue as a side-by-side diff, with a verification status and a named owner on every document.

Best for

When you want the maintenance and the permissions handled for you.

Sylph

Sylph, from nao Labs, puts the company brain in the git tree. A central CONTEXT.md sits at the root, domain folders hold each team's context, and every file is Markdown the agents read directly.

Agents write proposed improvements into a drafts folder and humans decide what lands.

After a change is published, the agent diffs its own draft against the human edit and updates its rules from the difference. Nothing else is automated, so the brain moves at review speed. It is open source with around 196 stars.

Best for

A shared team repo you can read in a pull request.

mem0

mem0 is a memory layer rather than a knowledge base. Your code calls add(), an LLM pulls the durable facts out of the text, and those facts land in a vector store scoped to a user, an agent, a session, or an organisation. Version 3 is add-only: instead of deleting stale facts, it applies memory decay at search time so older facts surface less. Open-core, with a $24M Series A behind it and roughly 62,000 stars.

Best for

Memory under agents you are building yourself.

Zep

Zep is built on Graphiti, its own open-source engine, which stores knowledge as a temporal knowledge graph, meaning a graph of facts that each carry the time they were true. Episodes go in and come out as three layers: the raw events, the entities extracted from them with typed connections, and communities that group related entities. When new information contradicts an older fact, an LLM expires the old relationship rather than deleting it, so you can still ask what the team believed in March. Retrieval needs no LLM call at all, which is why answers come back in under a second. Graphiti has around 24,000 stars.

Best for

Questions where the history matters as much as the current answer.

Letta

Letta comes out of the MemGPT research line and keeps three tiers of memory on Postgres: small labelled memory blocks that stay pinned in the context window, a searchable archive, and the full message history. A sleep-time agent rewrites the shared memory blocks in the background while nothing is waiting on it, and context compaction summarises about 30% of messages when the window fills. An Agent Development Environment lets a person open that memory and correct it by hand. Open-core, $10M seed.

Best for

When the agent should own and edit its own memory.

Cognee

Cognee, out of Berlin, describes itself as a shared company brain for agents. It connects sources like Slack, GitHub, and Linear, builds both a graph and vector representation of what it finds, and returns answers with citations back to the source. Those citations let a reader check an answer instead of trusting it. Around 30,000 stars and a $7.5M seed.

Best for

An open-source graph and vector platform you host yourself.

Where this goes next, and where Slite fits

GBrain proved the autonomous company brain is buildable. The next race is about autonomy you can trust.

Full autonomy is a great demo. It gets hard the moment an ambiguous change lands with no human to weigh in, and harder still when a whole team writes to the same brain.

GBrain has since added scoped multi-user access, but it started as, and largely remains, a single-player tool.

And multiplayer is only half of it. The deeper gap is governance and reach.

GBrain assumes one motivated person who can stand the system up, keep it running, and point it at data that mostly lives on their own machine.

But for a team, the obvious downsides are:

• It has no real permission model, so who can see what is never a first-class question.
• It reads from local files and a fixed set of signals; it does not natively plug into the team-wide systems where company knowledge actually lives, like CRMs, help desks, or SQL databases.

For an individual, this setup is fine. For a team, permissions and connected sources are most of the job.

We are building Slite Agent around the opposite default: a self-maintaining knowledge base with a person in the loop. Slite Agent is the maintenance layer on top of it. It watches for drift, drafts the fix, and asks someone to approve ambiguous changes before they land.

The aim is roughly 95% autonomy, with people kept in the loop for the 5% that actually needs judgment. And we point maintenance at the thing GBrain leaves alone: whether the knowledge is still accurate and complete.

The two approaches pull in different directions.

If your team is plugging agents into your company knowledge and you want it to stay trustworthy as it grows, that is the problem we are working on.

Book a demo and we will walk you through how Slite Agent handles drift and review.

The need for an AI memory layer is real, and GBrain showed one strong way to build it.

The open question it leaves on the table is the one that matters most as these systems take on more of our work: a well-organized brain is not yet a brain you can trust.

Closing that gap is the work ahead, and it is the part we are most excited about.