Vector-only RAG is hitting a hard architectural ceiling. Dump thousands of embeddings into a flat index, ask an agent to reason across multi-hop relationships or find missing context, and the system collapses into hallucinated noise or truncated context windows. Garry Tan, President and CEO of Y Combinator, recently released GBrain, a specialized memory and synthesis engine built to solve this exact bottleneck. In production benchmarks across 240 prose-rich pages, GBrain's graph-augmented retrieval beat raw ripgrep-BM25 and vector-only setups by 31.4% in Precision at 5 (P@5).
GBrain is designed as the core persistence and reasoning layer for agent runtimes like OpenClaw and Hermes. It treats memory not as a static document cache, but as an active, self-healing knowledge graph paired with asynchronous consolidation cycles.
The Dual-Layer Failure of Standard RAG
Most personal knowledge bases and retrieval pipelines operate on naive keyword grep or semantic proximity. Both fall short when agents require institutional memory:
- Information Fragmentation Without Gap Analysis: Standard search dumps isolated chunks into an LLM prompt. GBrain generates synthesized prose backed by explicit, grounded citations. More importantly, it performs automated Gap Analysis, explicitly declaring what is missing from the index rather than guessing.
- Expensive, Brittle Graph Construction: Traditional knowledge graphs rely on heavy LLM extraction pipelines that drive up inference costs and introduce latency. GBrain builds typed edges (such as
PERSON_WORKS_AT_COMPANYandPROJECT_DEPENDS_ON_PROJECT) directly upon page writes without making a single LLM call.
+-------------------------------------------------------------------+
| GBrain Core System |
+-------------------------------------------------------------------+
| Ingestion (Markdown/Wikilinks) -> entity-extractor.py (Regex) |
| | |
| v |
| Multi-Modal Storage <-------- Typed Edge Graph Generation |
| - PGLite (WASM Postgres 17) | |
| - Postgres + pgvector (HNSW) v |
| Hybrid Retrieval Engine |
| - BM25 + Vector (RRF) |
| - Intent Rewriting & Source Boost |
| - Adjacency & Cross-Source Graph Boost|
+-------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------+
| Background Processing & Exec |
| - Minions Job Queue (Two-Phase Persistence for Subagents) |
| - The Dream Cycle (Deduplication, Contradictions, Task Prep) |
+-------------------------------------------------------------------+
The difference in retrieval quality shows up immediately when querying relational data:
| Metric & Test Condition | GBrain (w/ Graph) | Graph Disabled | ripgrep-BM25 + Vector-Only RAG |
|---|---|---|---|
| P@5 (Precision at 5) | +31.4% Higher | Baseline | Baseline |
| Data Corpus | 240 Opus-generated prose-rich pages | 240 Opus-generated prose-rich pages | 240 Opus-generated prose-rich pages |
Under the Hood: The Dream Cycle and Ingestion Pipeline
GBrain runs an autonomous operational loop to capture, index, and refine intel continuously across 66 automated cron jobs.
1. Signal Capture (agent.say() and agent.ask())
Incoming data streams (meetings, emails, voice calls, notes, tweets) are intercepted at the agent boundary. Before routing queries out to expensive external APIs, the runtime issues an agent.ask() call against the local GBrain slice. This provides an immediate, localized context layer for the agent runtime.
2. Zero-LLM Entity Extraction (entity-extractor.py)
Whenever markdown notes or wikilinks enter the repository, entity-extractor.py scans the text using deterministic pattern matching. It resolves entities and registers relational graph edges without burning model tokens. Multi-hop queries such as "Who works at Acme AI?" or "What did Bob invest in this quarter?" resolve across graph paths via gbrain lookup --graph.
3. The Overnight "Dream Cycle"
Raw data ingestion tends to degrade over time through duplicates, dead citations, and conflicting facts. GBrain runs background maintenance jobs while the system is idle. This process deduplicates entity records, patches broken citation links, scores node relevance, highlights internal contradictions, and stages task queues for the following day.
Systems Architecture: Storage, Retrieval, and Execution
The infrastructure balances local developer velocity with multi-tenant team scaling.
+--------------------------------------------------------------------+
| Query Routing |
| |
| gbrain ask "Meeting context..." |
| | |
| +--> Mode: raw (Direct Vector / Keyword Fetch) |
| +--> Mode: hybrid (Reciprocal-Rank Fusion + Intent Rewrite) |
| +--> Mode: full (Adjacency Boost + Multi-Hop Graph) |
+--------------------------------------------------------------------+
- Storage Topology: For local-first workloads (up to ~50k pages), GBrain embeds PGLite (Postgres 17 running via WASM) requiring zero external infrastructure. For team deployments, it points directly to Postgres + pgvector (self-hosted or Supabase). The ground truth stays preserved as raw Markdown inside a Git-tracked "brain repo" that continuously syncs to Postgres.
- Hybrid Retrieval Stack: Retrieval combines HNSW indexing on pgvector with BM25 keyword matching via Reciprocal-Rank Fusion (RRF). Queries pass through intent-aware query rewriting, source-tier boosting, adjacency boosts, and cross-source boosts. Execution is tunable through three explicit modes:
raw,hybrid, andfull. - Subagent Resilience with Minions: To keep subagents from crashing mid-execution, GBrain includes Minions, a Postgres-native job queue. Minions implements a two-phase persistence model that preserves task state and enables self-healing recovery across process failures.
- Adaptive Schema Packs: System taxonomy is not hardcoded. The runtime ships with default schema definitions (
core.v1.0.json), but allows custom schemas. Swapping a schema pack triggers a dynamic re-interpretation of the underlying data without schema migration breakage. - Evaluation Framework: GBrain contains an internal dashboard to validate engine updates. It replays historical production queries against modified codebases, benchmarks retrieval deltas, and cross-evaluates task outputs against frontier models from three separate providers.
Deployment and Ecosystem Integration
GBrain is built to be bootstrapped directly by an autonomous agent. If you operate an agent on OpenClaw or Hermes, provisioning runs through a single command:
bashgbrain install --prod --openclaw --hermes
The automated installer configures the storage engine, generates system keys, registers 43 modular skills, schedules the 66 dream cycle jobs, and completes an end-to-end verification run within roughly 30 minutes.
bash# Querying synthesized context with gap detection gbrain ask "What do I need to know before my meeting with Alice tomorrow?"
For broader multi-client environments, GBrain exposes over 30 tools over the Model Context Protocol (MCP) using both stdio and HTTP transports. This provides native connectivity for:
- Claude Desktop and Code
- Cursor
- ChatGPT
- Perplexity
- Cowork
- Google Gemini
GBrain avoids treating memory as an unorganized bucket of text embeddings. By pairing zero-overhead graph indexing with hybrid retrieval and continuous offline synthesis, it gives agents a durable, self-correcting memory layer ready for high-reliability production workflows.