Gbrain

Overview

GBrain is an open-source, markdown-first knowledge brain for AI agents. It turns a git repo of notes into a queryable system of record: hybrid vector + keyword search, a self-wiring typed knowledge graph, a synthesis layer that answers with citations and gap analysis, and overnight “dream cycle” jobs that enrich and consolidate memory while you sleep. Creator Garry Tan (President and CEO of Y Combinator) open-sourced it on 5 April 2026 as the production brain behind his own OpenClaw and Hermes agent deployments.

As of mid-July 2026 the primary repo is github.com/garrytan/gbrain (TypeScript / Bun, default branch master, MIT). Public signals at research time: on the order of ~26.6k GitHub stars, ~3.8k forks, and a busy issue tracker. Package version file reports v0.42.x (e.g. 0.42.62.0). Tan’s published personal deployment scale (from the README): 146,646 pages, 24,585 people, 5,339 companies, and dozens of autonomous cron jobs.

Primary job: stop agent amnesia about everything that isn’t in the current chat window. GBrain is the retrieval + synthesis layer on top of plain-text knowledge you own. It is not a hosted multi-tenant memory SaaS; it is self-hosted infrastructure (PGLite for local brains, Postgres + pgvector for larger / shared / multi-machine setups) with first-class MCP (stdio and HTTP) for coding agents and harnesses.

Key features

• Markdown system of record — Knowledge lives in a normal git “brain repo.” GBrain syncs markdown into Postgres for retrieval; deletes soft-delete in the DB. You can git diff what the agent learned overnight, branch, and rebuild the index from files if the database disappears.
• Two query modes — gbrain search returns ranked pages (hybrid score, no LLM cost). gbrain think synthesizes an answer with citations and an explicit gap analysis (stale pages, uncited claims, contradictions, holes to fill).
• Hybrid retrieval — Vector (HNSW / pgvector) + BM25-style keyword (Postgres FTS) + reciprocal rank fusion + source-tier boosts + optional reranker. Named search modes: conservative, balanced (default), tokenmax. Explain/diagnose tooling: gbrain search --explain, gbrain search diagnose.
• Self-wiring knowledge graph — On write, entity refs and typed edges (attended, works_at, invested_in, founded, advises, …) extract with zero LLM calls (pattern/wikilink rules). Graph signals lift retrieval; multi-hop via gbrain graph-query.
• Published BrainBench numbers — On a 240-page rich-prose corpus in sibling repo gbrain-evals: full system P@5 49.1%, R@5 97.9%, about +31.4 P@5 vs graph-disabled and similar margin vs BM25 + vector-only RAG. LongMemEval harness also ships (gbrain eval longmemeval).
• Dream cycle / enrichment — Cron-driven overnight work: dedupe people, fix citations, score salience, surface contradictions, prep tasks. Tiered enrichment promotes frequently mentioned entities. Signal detector captures ideas and entities from agent traffic.
• Schema packs — No single fixed folder taxonomy. Bundled packs include gbrain-base-v2 (default 15-type DRY/MECE taxonomy as of v0.41.22+), legacy gbrain-base, and gbrain-recommended. Operators (or agents) author packs via gbrain schema detect|suggest|review-candidates|use.
• Compiled truth + timeline — Pages keep a current summary (“compiled truth”) above an append-only timeline so memory neither goes stale silently nor grows as unreadable dumps.
• MCP server (30+ tools) — gbrain serve (stdio) and gbrain serve --http (OAuth 2.1 + admin dashboard). Documented clients: Claude Code, Codex, Cursor/Windsurf, Claude Desktop/Cowork, Perplexity Computer, ChatGPT (OAuth/PKCE). Scopes: read / write / admin.
• Company brain — Multi-user, login-scoped institutional memory (tutorial for ~10–50 person teams). README claims fuzz-tested isolation across search/list/lookup/multi-source reads with zero leaks; aligns with YC’s “company-brain” RFS shape.
• Minions job queue — Postgres-native durable jobs for subagents, shell work, rate leases, and crash-safe two-phase persistence (not fire-and-forget Promises).
• Ingestion surface — gbrain capture / import / webhook ingest / ~/.gbrain/inbox/; recipes for voice (Twilio), meeting webhooks, embedding providers (OpenAI, ZeroEntropy default, Voyage, Gemini, Ollama, llama.cpp, …).
• Skills pack — Dozens of markdown skills (signal, ingest, enrichment, ops, eval, migrations). “Thin harness, fat skills” ethos: behavior lives in readable skill files, not opaque framework config.
• Ops tooling — gbrain doctor, spend controls for embedding bills, multi-language FTS config, eval export/replay, skillopt for measurable skill improvement.

Pricing

GBrain software is free open source under the MIT License (Copyright 2026 Garry Tan). There is no vendor seat fee, cloud subscription, or metered product SKU from the project itself. Real money you spend is downstream of how you run it.

Cost item	Typical amount	Notes
GBrain software	$0	Clone from GitHub; Bun install / agent install
Local DB (PGLite)	$0	Default personal path; Postgres 17 via WASM; README cites ~2s init, practical up to ~50K pages
Managed / shared Postgres	Free tier → paid	Supabase or self-hosted Postgres + pgvector for large / multi-user brains
Embeddings	Provider rates	Required for vector search. Independent reviews cite order-of-magnitude ~$0.10 / M tokens for common OpenAI embedding pricing at write time of those reviews; ZeroEntropy is the documented default stack; local Ollama / llama.cpp also supported
Optional LLM calls	Provider rates	think synthesis, query expansion, enrichment tiers, skillopt judges — avoidable on pure search paths
Host / agent platform	Varies	AlphaClaw on Render, Hermes on Railway, VPS, laptop — your choice

VersusTools pricing fields: pricing_model = open_source, starting_price = 0. Independent May 2026 reviews described active personal brains as often single-digit dollars per month in API spend when entity extraction stays deterministic (zero LLM per write) and you gate enrichment. Project docs ship spend.posture (gated vs tokenmax) and related spend controls so a runaway sync cannot silently explode embedding cost.

Limits & gotchas

• Opinionated audience — Best fit for operators who want a personal or small-team markdown brain with OpenClaw, Hermes, or MCP-wired coding agents. It is a poor default if you need turnkey multi-tenant memory for a SaaS product serving thousands of end users.
• Young, fast-moving codebase — Frequent minor/patch waves; breaking changes and migration pain appear in public issues (schema upgrades, dream-cycle disconnects, large-sync stalls). Pin versions and run gbrain doctor after upgrades.
• Schema / skill discipline — Value compounds when you maintain types, skills, and capture hygiene. “Set and forget” without authoring skills underdelivers; that is a design trade-off, not a free lunch.
• Empty brain on day one — Without gbrain import (Obsidian/notes) or weeks of agent capture, retrieval has nothing useful to synthesize. Import first if you already have a vault.
• PGLite constraints — Single-writer; stop gbrain serve during large syncs. README documents PGLite crashes on some macOS 26.x / Apple Silicon setups — use Homebrew Postgres + pgvector instead. Soft ceiling ~50K pages for personal PGLite; scale to Postgres for bigger corpora.
• Graph vs multi-hop product claims — Typed edges and graph-boosted ranking are real and benchmarked, but independent reviews note multi-hop / temporal reasoning as primary retrieval strategies are less of a product focus than hybrid search + backlink boosts. Workloads that need bi-temporal KG productization may prefer Zep/Graphiti-class tools.
• Optional SaaS enrichment — Some recipes/skills point at paid transcription or contact-enrichment services. The core brain does not require them; Reddit operators correctly flag that “recommended” add-ons can add real monthly cost.
• Remote MCP security — SECURITY.md is explicit: do not expose open OAuth client registration on a public URL. Prefer token auth via gbrain serve --http + gbrain auth create, or pre-register clients without open DCR. An attacker who can self-register can obtain tokens and read the brain.
• Privacy is self-hosted, not certified — Data can stay on your hardware, but you still operate backups, access tokens, tunnels (ngrok/Tailscale), and agent write permissions. No SOC2 packet ships with the OSS project.
• Benchmark honesty context — BrainBench is reproducible in gbrain-evals and generally praised for matching the marketing to the code, but scores are corpus-specific and not automatically comparable to BEAM / commercial LongMemEval marketing tables from other vendors.

Community sentiment

Launch reception mixed celebrity gravity with real technical interest. The repo climbed thousands of stars in the first days (reviews in May 2026 already cited ~5k stars in 24 hours and ~14k soon after; mid-July totals sit much higher). Discussion clusters on Reddit (r/openclaw, r/hermesagent), Hacker News, X/LinkedIn launch threads, and long-form reviews.

Praise: markdown ownership; zero-LLM entity graph on write; hybrid search that feels better than “vector dump”; agent-install UX; dream cycle compounding; honest README on install gotchas; production-shaped ops (Minions, doctor, spend gates). Operators who already live in OpenClaw/Hermes report the largest delta. YouTube and blog walkthroughs treat GBrain as the practical “second brain for agents,” not just another RAG demo.

Skepticism / friction: YC-CEO halo inflates attention (reviewers admit this while still liking the engineering); early multi-tenant readiness was weak (company-brain work arrived later); install/upgrade issues and npm name squat; concern that recommended YC-adjacent SaaS tools for transcription/enrichment raise TCO; category confusion with Mem0/Zep/Hindsight/MemPalace (different products, overlapping vocabulary). Reddit memory-provider threads often label GBrain as a personal second brain, not “drop-in product memory API.”

Overall mid-2026 consensus: strong pick for self-hosted agent operators who will invest months; wrong pick if you wanted a managed memory API tomorrow.

Who should use it

• OpenClaw or Hermes operators who want total recall over thousands of markdown files and overnight enrichment.
• Founders, investors, researchers, and exec assistants building a personal people/companies/deals brain with meeting prep via think.
• Claude Code / Codex / Cursor users who will wire MCP and adopt a brain-first protocol in CLAUDE.md / AGENTS.md.
• Small teams (roughly 10–50) willing to run the company-brain tutorial with OAuth scoping and shared institutional memory.
• Obsidian / plain-markdown power users who want git-diffable knowledge plus hybrid search without abandoning files.

Skip (or use only as a side personal brain) if you need multi-tenant SaaS memory, 40+ vendor integrations out of the box, or zero-ops managed hosting.

Alternatives

• MemPalace — Local-first verbatim memory; strong “zero API key” path; different metaphor and storage stack.
• NotebookLM — Google source-grounded research notebooks; consumer/enterprise freemium, not a self-hosted agent brain.
• Obsidian — Human-first PKM vault; pair with GBrain as the agent retrieval layer rather than a full substitute.
• Logseq — Outliner PKM; similar “files first” ethos without the agent dream cycle.
• Claude Code — Coding agent client; use with GBrain via MCP rather than as memory itself.
• LangChain / LlamaIndex — Framework RAG stacks when you are building product memory pipelines, not a personal markdown brain.
• Mem0 / Zep / Hindsight / Letta / Cognee (external) — Production or managed memory platforms; better when you need multi-tenant APIs, temporal product KG, or agent OS memory without running GBrain ops.

Verdict

GBrain is one of the most complete self-hosted, markdown-native agent brains available in 2026: hybrid search, typed graph, synthesis with gap analysis, durable jobs, MCP, and an explicit path from personal brain to company brain. The software is free; you pay embeddings, optional LLM enrichment, and the discipline to capture and shape the schema. It rewards multi-month commitment and a compatible agent harness more than a weekend trial. If that profile matches how you work, install from the official GitHub repo and treat gbrain doctor as part of weekly ops. If you wanted memory-as-a-service with vendor SLAs, look at managed alternatives and keep GBrain only if you still want a personal knowledge moat under your own keys.