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.
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.
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, so read it as 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.
That overnight run is where both the magic and the limits show up.
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.
This is the catch, and it is easy to miss because a tidy brain looks like a trustworthy one.
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 builders we talk to 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.
One caveat worth stating plainly: 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.
| Usage profile | Rough cost | What drives it |
|---|---|---|
| Light (ingest plus occasional search) | ~$4 / user / mo | embeddings, storage |
| Heavy (frequent querying) | ~$8 to 15 / user / mo | querying (a model call per search) |
Bottom line: A company brain like this is cheap to build and keep current. What you pay for is querying it.
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, so it helps to see them side by side:
| GBrain | Slite Agent | |
|---|---|---|
| Best for | Individuals and power users | Teams |
| Setup and upkeep | You build and maintain it | Managed and maintained for you |
| Knowledge graph | Persistent, typed, hardcoded relationships | No persistent graph; infers context at query time |
| Data sources | Local files and a fixed set of signals | Connects to the team tools where knowledge lives |
| Permissions | Bolt-on scoped access | Governed and first-class |
| Maintenance goal | Keeps the brain organized | Targets drift, accuracy, and completeness |
| Human in the loop | Optional orphan report | Built in for ambiguous changes |
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.
