garrytan/gbrainPublic

Garry's Opinionated OpenClaw/Hermes Agent Brain

AI summary: A highly customized local knowledge brain daemon for executing the OpenClaw and Hermes AI agents.

Stars
33.3K
+260 today
Forks
5K
Watchers
133
Open issues
288
Open PRs
42
Contributors
~140
Commits
16.1K
Branches
2K

TypeScriptMITCreated Apr 5, 2026Last push 2d agoLatest release v0.60.739.0+630 stars this week+2.3K this month

Quick answers

What is gbrain?
A highly customized local knowledge brain daemon for executing the OpenClaw and Hermes AI agents.
What does gbrain do?
GBrain serves as the synthesis and retrieval backend for autonomous agent deployments. It runs locally as a 24/7 daemon using a PGLite database, processing thousands of ingested documents including meetings, emails, and notes. Instead of simply relying on vector search, it actively builds a semantic knowledge graph by identifying typed relationships between entities (like people, companies, and deals) automatically. This enables conversational agents to synthesize comprehensive answers with explicit citations, perform gap analysis on missing information, and consolidate institutional memory without manual data entry or external API calls.
Who is gbrain for?
Founders, executives, and AI developers looking to run private, graph-enhanced retrieval augmented generation (RAG) systems for their autonomous agents. The platform makes it simple to recall past research and connect isolated ideas effectively. Users can structure their thoughts into a comprehensive network of interconnected nodes.
How do I get started with gbrain?
Configure your API keys using the interactive prompt to initialize the local PGLite database.
How popular is gbrain on GitHub?
garrytan/gbrain has 33,283 stars and 4,981 forks on GitHub, and gained 630 stars in the last 7 days.
What license does gbrain use?
garrytan/gbrain is released under the MIT license.

Star history

since Jul 29, 2026
010K20K30KJul 2026Sep 2026Oct 2026Nov 2026
33.3K stars as of Nov 18, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Update history

6 recorded
  • Nov 18, 2026New release v0.60.739.0 (previously v0.60.675.0).
  • Nov 11, 2026New release v0.60.675.0 (previously v0.60.573.0).
  • Nov 4, 2026New release v0.60.573.0 (previously v0.60.452.0).
  • Oct 25, 2026New release v0.60.452.0 (previously v0.60.289.0).
  • Oct 17, 2026New release v0.60.289.0 (previously v0.60.108.0).
  • Oct 8, 2026New release v0.60.108.0 (previously v0.59.18.0).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 0 commits2026-03-13: 0 commits2026-03-14: 0 commits2026-03-15: 0 commits2026-03-16: 0 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 0 commits2026-03-26: 0 commits2026-03-27: 0 commits2026-03-28: 0 commits2026-03-29: 0 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 2 commits2026-04-06: 2 commits2026-04-07: 1 commit2026-04-08: 2 commits2026-04-09: 30 commits2026-04-10: 45 commits2026-04-11: 21 commits2026-04-12: 18 commits2026-04-13: 7 commits2026-04-14: 4 commits2026-04-15: 0 commits2026-04-16: 2 commits2026-04-17: 0 commits2026-04-18: 4 commits2026-04-19: 9 commits2026-04-20: 10 commits2026-04-21: 11 commits2026-04-22: 10 commits2026-04-23: 8 commits2026-04-24: 8 commits2026-04-25: 4 commits2026-04-26: 7 commits2026-04-27: 3 commits2026-04-28: 7 commits2026-04-29: 15 commits2026-04-30: 8 commits2026-05-01: 2 commits2026-05-02: 4 commits2026-05-03: 12 commits2026-05-04: 9 commits2026-05-05: 0 commits2026-05-06: 15 commits2026-05-07: 19 commits2026-05-08: 4 commits2026-05-09: 20 commits2026-05-10: 31 commits2026-05-11: 22 commits2026-05-12: 2 commits2026-05-13: 5 commits2026-05-14: 16 commits2026-05-15: 4 commits2026-05-16: 2 commits2026-05-17: 16 commits2026-05-18: 26 commits2026-05-19: 11 commits2026-05-20: 9 commits2026-05-21: 11 commits2026-05-22: 21 commits2026-05-23: 16 commits2026-05-24: 13 commits2026-05-25: 42 commits2026-05-26: 13 commits2026-05-27: 12 commits2026-05-28: 8 commits2026-05-29: 3 commits2026-05-30: 18 commits2026-05-31: 2 commits2026-06-01: 14 commits2026-06-02: 3 commits2026-06-03: 24 commits2026-06-04: 2 commits2026-06-05: 0 commits2026-06-06: 0 commits2026-06-07: 15 commits2026-06-08: 6 commits2026-06-09: 2 commits2026-06-10: 4 commits2026-06-11: 0 commits2026-06-12: 11 commits2026-06-13: 0 commits2026-06-14: 4 commits2026-06-15: 0 commits2026-06-16: 6 commits2026-06-17: 8 commits2026-06-18: 0 commits2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 2 commits2026-06-22: 0 commits2026-06-23: 0 commits2026-06-24: 2 commits2026-06-25: 0 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 0 commits2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 4 commits2026-07-03: 0 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 2 commits2026-07-07: 0 commits2026-07-08: 0 commits2026-07-09: 0 commits2026-07-10: 2 commits2026-07-11: 0 commits2026-07-12: 0 commits2026-07-13: 7 commits2026-07-14: 0 commits2026-07-15: 0 commits2026-07-16: 41 commits2026-07-17: 86 commits2026-07-18: 3 commits2026-07-19: 0 commits2026-07-20: 35 commits2026-07-21: 60 commits2026-07-22: 45 commits2026-07-23: 325 commits2026-07-24: 103 commits2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 59 commits2026-07-28: 85 commits2026-07-29: 13 commits2026-07-30: 2 commits2026-07-31: 11 commits2026-08-01: 105 commits2026-08-02: 20 commits2026-08-03: 2 commits2026-08-04: 9 commits2026-08-05: 6 commits2026-08-06: 0 commits2026-08-07: 2 commits2026-08-08: 6 commits2026-08-09: 11 commits2026-08-10: 17 commits2026-08-11: 11 commits2026-08-12: 66 commits2026-08-13: 67 commits2026-08-14: 24 commits2026-08-15: 21 commits2026-08-16: 23 commits2026-08-17: 23 commits2026-08-18: 7 commits2026-08-19: 7 commits2026-08-20: 1 commit2026-08-21: 13 commits2026-08-22: 1 commit2026-08-23: 4 commits2026-08-24: 6 commits2026-08-25: 2 commits2026-08-26: 56 commits2026-08-27: 24 commits2026-08-28: 5 commits2026-08-29: 22 commits2026-08-30: 2 commits2026-08-31: 10 commits2026-09-01: 36 commits2026-09-02: 2 commits2026-09-03: 1 commit2026-09-04: 0 commits2026-09-05: 0 commits2026-09-06: 3 commits2026-09-07: 31 commits2026-09-08: 0 commits2026-09-09: 0 commits2026-09-10: 3 commits2026-09-11: 1 commit2026-09-12: 0 commits2026-09-13: 0 commits2026-09-14: 0 commits2026-09-15: 34 commits2026-09-16: 0 commits2026-09-17: 2 commits2026-09-18: 0 commits2026-09-19: 0 commits2026-09-20: 0 commits2026-09-21: 5 commits2026-09-22: 8 commits2026-09-23: 15 commits2026-09-24: 10 commits2026-09-25: 13 commits2026-09-26: 1 commit2026-09-27: 0 commits2026-09-28: 13 commits2026-09-29: 21 commits2026-09-30: 28 commits2026-10-01: 212 commits2026-10-02: 337 commits2026-10-03: 406 commits2026-10-04: 566 commits2026-10-05: 758 commits2026-10-06: 676 commits2026-10-07: 578 commits2026-10-08: 849 commits2026-10-09: 475 commits2026-10-10: 782 commits2026-10-11: 353 commits2026-10-12: 602 commits2026-10-13: 419 commits2026-10-14: 443 commits2026-10-15: 951 commits2026-10-16: 1203 commits2026-10-17: 1051 commits2026-10-18: 970 commits2026-10-19: 466 commits2026-10-20: 521 commits2026-10-21: 944 commits2026-10-22: 461 commits2026-10-23: 440 commits2026-10-24: 504 commits2026-10-25: 463 commits2026-10-26: 550 commits2026-10-27: 261 commits2026-10-28: 294 commits2026-10-29: 312 commits2026-10-30: 320 commits2026-10-31: 911 commits2026-11-01: 320 commits2026-11-02: 349 commits2026-11-03: 444 commits2026-11-04: 217 commits2026-11-05: 229 commits2026-11-06: 483 commits2026-11-07: 265 commits2026-11-08: 277 commits2026-11-09: 1145 commits2026-11-10: 479 commits2026-11-11: 529 commits2026-11-12: 496 commits2026-11-13: 521 commits2026-11-14: 410 commits2026-11-15: 92 commits2026-11-16: 62 commits2026-11-17: 142 commits2026-11-18: 63 commits2026-11-19: 19 commits2026-11-20: 0 commits2026-11-21: 0 commits
27,032 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    33,283 stars

  • Very active

    27,032 commits in 52 weeks

  • Community-driven

    ~140 contributors

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    6 trending appearances

What gbrain does

GBrain serves as the synthesis and retrieval backend for autonomous agent deployments. It runs locally as a 24/7 daemon using a PGLite database, processing thousands of ingested documents including meetings, emails, and notes. Instead of simply relying on vector search, it actively builds a semantic knowledge graph by identifying typed relationships between entities (like people, companies, and deals) automatically. This enables conversational agents to synthesize comprehensive answers with explicit citations, perform gap analysis on missing information, and consolidate institutional memory without manual data entry or external API calls.

Founders, executives, and AI developers looking to run private, graph-enhanced retrieval augmented generation (RAG) systems for their autonomous agents. The platform makes it simple to recall past research and connect isolated ideas effectively. Users can structure their thoughts into a comprehensive network of interconnected nodes.

  • Local agent backend: Runs 24/7 on local hardware to continually digest and organize incoming data streams.
  • Knowledge graph generation: Automatically extracts entities and constructs typed relationship edges (e.g., 'works_at') during ingestion.
  • Synthesized answers: Returns cohesive, cited prose answers summarizing multiple sources rather than raw list results.
  • Zero-leak multi-tenant scoping: Implements strict login-scoped data separation when deployed as a shared company brain.
  • PGLite database integration: Bootstraps a local database almost instantaneously without requiring external server setup.

Where teams use it

Agentic memory enhancement

Developers integrate the system directly into agents like Claude Code to provide them with persistent, structured long-term memory.

Meeting preparation

Executives query the brain before meetings to instantly retrieve a synthesized history of past interactions, deals, and open action items.

Institutional memory

Companies deploy a shared instance to consolidate and securely query distributed knowledge across different teams.

Automated data enrichment

Autonomous cron jobs run overnight to process raw inputs, extract entities, and refine the knowledge graph without human intervention.

Getting started: Configure your API keys using the interactive prompt to initialize the local PGLite database.

README

master branch

GBrain

One brain for you and your company, read by every agent you use. Put your own notes and your company's docs in one place: a facts page, a decisions log, call transcripts. Claude Code, Codex and your other agents look there before they answer, so they stop starting from zero and work from what you and your team actually wrote down.

GBrain is MIT-licensed and free to self-host, and it starts with no API keys: search is by keyword until you add one. gbrain.io is optional paid hosting.

Tip

Need hosted? First time running an agent? Try gbrain.io, hosted GBrain, for the easiest experience: one brain for you and your team, connected to ChatGPT, Claude and Cursor, with nothing to install or keep online. Stuck? Email [email protected] and a person will set it up with you, free.

A few minutes after you install it:

  • Every new Claude Code or Codex session looks in your brain before it answers, without being told to.
  • Anything you ask your agent to remember is still there in the next session, in every agent connected to the brain.
  • Your notes and your company's docs are searchable, and your agent answers questions like "what did we decide about pricing, and why?" from them.

Works with these agents (each name links to its guide):

How it connects Agents
One command wires memory, hooks and instructions Claude Code (gbrain setup claude-code), Codex (gbrain setup codex)
MCP from its guide, then gbrain setup <name> adds the brain-first instructions OpenClaw, Hermes, opencode, Cursor
MCP from its guide ChatGPT, Claude Desktop, Claude Cowork, Perplexity, Grok Build, Grok Bot, Muse, Windsurf and other stdio clients
Any other coding agent Paste the install prompt below

Stability

New releases come out many times a day, but the install command below gives you the stable channel: a release reaches it only after the full test suite and a two-hour, 600,000-page load test pass on that exact release, and only when an important fix is waiting or stable is a week old. Updates are never installed without your say-so unless you turn on automatic upgrades. After an upgrade, gbrain shows a one-time notice listing what changed in behaviour. Stable also comes with a written promise about which commands, flags, tools, config keys and output fields stay the same, and how much warning you get before one changes. docs/STABILITY.md explains that promise, how often stable moves, how to pin a version or go back, and what the faster alpha channel is for.

Install

Tip

Fastest: hosted GBrain at gbrain.io, for any harness. One command launches a GBrain hosted on gbrain.io; Claude Code, Codex, ChatGPT, Cursor and every other AI you use connect to it, with nothing to keep online.

curl -sSL https://gbrainio.terminalwire.sh | bash
gbrainio terminal connect      # in a new terminal
gbrainio workspace new         # pick a plan in the browser
curl -fsSL https://bun.sh/install | bash   # skip if Bun 1.4.4+ is installed
export PATH="$HOME/.bun/bin:$PATH"
bun install -g github:garrytan/gbrain#stable   # the gbrain CLI only; no local brain
# Claude Code (an existing gbrain entry is kept):
(claude mcp get gbrain >/dev/null 2>&1 || claude mcp add --transport http --scope user gbrain https://gbrain.io/mcp) && gbrain setup claude-code --instructions-only
# Codex (an existing gbrain entry is kept):
(codex mcp get gbrain >/dev/null 2>&1 || codex mcp add gbrain --url https://gbrain.io/mcp) && gbrain setup codex --instructions-only

Bun's installer needs unzip and stops with error: unzip is required to install bun without it. Check with command -v unzip; if it prints nothing, install it first: apt-get update && apt-get install -y unzip (Debian, Ubuntu), dnf install -y unzip (Fedora, RHEL) or apk add unzip (Alpine), with sudo in front unless you are root. No way to install packages? Use the no-unzip route, not an improvised one.

gbrain setup <harness> --instructions-only tells the agent the brain is there; agents seldom call an MCP server nobody told them about. It writes the brain-first block into ~/.claude/CLAUDE.md or Codex's AGENTS.md (a non-empty AGENTS.override.md instead when Codex has one) with a per-turn rule hook, and leaves the MCP entry alone; the same command with --no-instructions added takes them out.

The installer is a shell script for macOS and Linux; read it before you run it.

Here's how to self-host it

GBrain is MIT-licensed and free to self-host. It needs Bun 1.4.4 or newer; existing worker installs read the authorization and queue upgrade guide before restarting on this version.

Warning

GBrain is NOT distributed on npm. The npm gbrain package is unrelated and can shadow the real binary, so never run npm install -g gbrain or bun add -g gbrain. Install only via bun install -g github:garrytan/gbrain#stable (the soaked stable channel; #latest-stable is the alpha line with every release) or git clone --branch stable + bun install && bun link. Installed by mistake? gbrain doctor gives the fix. Schema not migrated (#218)? Run gbrain apply-migrations --yes --no-autopilot-install; if it exits 1, run gbrain doctor --json, not another --yes (wedged: relay its fix).

bun install -g github:garrytan/gbrain#stable
gbrain setup claude-code              # or: gbrain setup codex
gbrain init --pglite --no-embedding   # any other harness, or no agent

gbrain setup shows what it will write first (--dry-run previews, --remove undoes), creates a keyless brain only if none exists, wires MCP, hooks and a brain-first block in the agent's instruction file (--no-instructions skips it), and smoke-tests them (setup guide). For any other coding agent, paste:

Add GBrain memory to this existing agent. Read and follow:
https://raw.githubusercontent.com/garrytan/gbrain/master/INSTALL_FOR_AGENTS.md
Keep my current identity and instructions, start keyless, and show me the
search-mode choice. Verify a remember/recall round trip with real GBrain calls.

Postgres, thin clients, API keys and upgrades: docs/INSTALL.md. Agents: INSTALL_FOR_AGENTS.md. Memory-only walkthrough: give your coding agent a memory.

Add your notes and your company's docs

Point GBrain at two folders of Markdown files: your own notes (an Obsidian vault works) and your company's docs. In the company folder, keep facts.md (numbers and statements agents may repeat), decisions.md (each decision with its date, its reason and who made it) and call transcripts saved as .md files.

gbrain sources add notes --path ~/notes --federated --force      # your notes
gbrain sources add company --path ~/company --federated --force  # company docs
gbrain sync --all                                                # rerun after edits

Then open a new agent session and ask "What did we decide about a free plan, and why?": the answer comes from your decisions log. --federated puts the folder in default search, and --force accepts a folder that isn't a git repository; in a folder that is one, GBrain reads only committed files, so commit your edits before you sync. To see the shape first, gbrain sources demo company-brain runs a fictional company in a few seconds without touching your brain. Before you share a company brain with a team, read the company-brain tutorial.

GBrain is not a data warehouse or analytics store. Keep ads, analytics, CRM and payment data in your warehouse, and connect your agent to it separately.

CLI standalone (no agent)

gbrain init --pglite --no-embedding   # keyless; no server, no Docker
gbrain import ~/notes/ --no-embed     # index your markdown
gbrain search "a phrase from a note" --json
gbrain doctor                         # verify health

Optional: a new personal agent

To have GBrain create a new persistent personal agent with identity files and its own private GitHub repo, open Codex (CLI or ChatGPT desktop) or Claude Code in a new, empty folder and paste:

Read and follow every step of:
https://raw.githubusercontent.com/garrytan/gbrain/stable/BOOTSTRAP_FOR_AGENTS.md
Goal: set yourself up as my persistent personal agent in this folder, with gbrain
as your memory. Interview me before writing any identity file — never invent
answers. Ask before anything destructive. You are not done until
`gbrain bootstrap verify` exits 0.

The repo is not a complete backup; see the bootstrap guide. For the always-on version (24/7 ingestion and the overnight dream cycle on a server with 8GB+ RAM and its own API usage), run GBrain under OpenClaw or Hermes and point it at INSTALL_FOR_AGENTS.md; the personal-brain tutorial walks it end to end.

Connect GBrain to your AI client (MCP)

  • Local stdio client: gbrain setup claude-code or gbrain setup codex registers gbrain serve (lists the memory verbs; --surface full lists every tool) behind gbrain's launcher, so a session opened in a cloned repository never loads that repository's bunfig.toml or .env, and adds the brain-first instructions: agents seldom call a brain nobody told them about. Cursor, Windsurf and other stdio clients take "$(command -v gbrain)" serve --surface starter --advertise verbs.
  • Plugins with curated skills: Codex codex plugin marketplace add garrytan/gbrain@codex-plugin + codex plugin add gbrain@gbrain; Claude Code /plugin marketplace add garrytan/gbrain + /plugin install gbrain@gbrain.
  • This brain from anywhere: gbrain mcp expose publishes it on your Tailscale tailnet as a user service (--funnel for cloud agents such as Grok Bot, Muse and ChatGPT). Guide.
  • A brain on another host: gbrain connect https://your-host/mcp --token gbrain_xxx --install (add --agent codex for Codex). Hosted brains use native OAuth or a private handoff; dashboard, clients and permissions live in MCP administration.

Per-client guides: Claude Code · Codex · ChatGPT · Claude Desktop · Claude Cowork · Perplexity · Hermes · OpenClaw · opencode · Grok Build · Grok Bot · Muse · everything MCP.

Keep skills beside knowledge. New local brains include memory skills in their content root. Agents can join an authorized catalog; only approved editors can publish. Managed coding-agent installs add an owned native router; restart and real-use verification are separate steps. Staged migration preserves sharing choices and personal edits. See shared brain skills.

Choose your setup

  1. Add GBrain to my existing agent — recommended. Keep your agent's identity and save memory inside its environment. No new personal-agent identity or private repository is required. Start with the guide for Grok Bot, Muse, or Codex / Claude Code. Other harnesses.
  2. Use the brain on my own computer from everywhere. One command publishes it over MCP on your Tailscale tailnet and keeps it running: gbrain mcp expose (add --funnel for cloud agents such as Grok Bot, Muse and ChatGPT). Follow use your brain from anywhere over MCP. Say to your agent: "use my brain over mcp" — "put my brain on tailscale".
  3. Connect my existing hosted brain. Follow hosted harness access to choose native OAuth or a private machine connection. For dashboard login, clients, and permissions, use MCP administration with the server's separate owner credential. Delegation is an explicit choice.

Grok Bot and Grok Build are different products. Muse's personal agent and Muse Code are different products too. Muse already has native editable memory; GBrain adds an explicit, portable record with provenance and shared access. See each guide's dated evidence and remaining verification steps.

I'm Garry Tan, President and CEO of Y Combinator. I built GBrain to run my own AI agents. It's the production brain behind my OpenClaw and Hermes deployments: 155,795 pages, 24,589 people, 5,340 companies, 66 cron jobs running autonomously. My agent ingests meetings, emails, tweets, voice calls, and original ideas while I sleep. It enriches every person and company it encounters. It fixes its own citations and consolidates memory overnight. I wake up smarter than when I went to bed — and so will you.

It works as a company brain too. Authenticated remote clients are constrained by source and operation grants plus visibility filters. Local files and shared database credentials are a different trust boundary: sources alone do not isolate those callers. The authorization tests exercise specific access paths, not a universal no-leak guarantee. Read the sharing boundaries and company-brain tutorial before setting up shared access.

Alongside keyword and semantic retrieval, GBrain offers two optional ways to use your stored knowledge:

  • A synthesis layer that gives you the actual answer. Synthesized, well-cited prose across people, companies, deals, and ideas. Not "here are 10 chunks that mention your query"; an actual answer with citations and an explicit note on what the brain doesn't know yet. The gap analysis is the part that changes how you use the brain.
  • A typed knowledge graph. Trusted local page writes extract supported references without LLM calls when auto-linking is enabled. Remote put_page edges arrive later, via sweeps, maintenance or add_link. Ask "who works at acme-example?": walks are breadth-first, milliseconds on dense clusters (how). On BrainBench relationship questions, relationship retrieval lifts production R@5 from 0.6626 to 0.7241 (benchmark); 0.9791 is the graph-oracle-parse upper bound, not a product score.

The point of building a 150K-page brain is to use it as a strategic moat. To never lose context. To query what's in your own head without re-reading it. The brain layer is what makes the moat usable. The 24/7 dream cycle is what keeps it sharp. Both run on your hardware, your DB, your keys.

It's easier to ship a daemon that runs 24/7 to ingest, enrich, and consolidate than it is to keep an agent in chat working hard. GBrain is that daemon, generalized. Install in 30 minutes. Your agent does the work. As my personal agent gets smarter, so does yours.

Start keyless. Your harness subscription and any separately configured model API usage are different costs. The optional personal-agent bootstrap takes about 15 minutes; always-on enrichment needs its own compute and API configuration.

Durable preferences and facts can be shared across agents; transient task and harness configuration state stay local. Configured cloud embedding, reranking, extraction, and synthesis providers can receive text, and the harness model sees recalled memory even in keyless mode. Markdown export is not a full database backup. Read memory boundaries.

LLMs: fetch llms.txt for the documentation map, or llms-full.txt for the same map with core docs inlined in one fetch. Agents: start with AGENTS.md (or CLAUDE.md if you're Claude Code).

What this looks like

Say you have a meeting with Alice tomorrow. You want to walk in remembering what she works on, when you last talked, and what's still open between you. Here's what you'd type, and what you'd get back.

You ask:

"What do I need to know before my meeting with Alice tomorrow?"

Most personal-knowledge tools give you back a list of pages. Something like:

1. people/alice — Alice runs engineering at Acme...
2. meetings/2026-03-15-alice-q1 — Q1 product review with Alice...
3. meetings/2026-01-08-acme-kickoff — Kickoff meeting with Acme team...
4. customers/acme — Acme is a series-B fintech we work with...
5. notes/2026-04-22 — Quick chat with Alice about pricing...

Five pages you now have to open and read yourself to actually prepare. The tool found the right material, but it didn't do the work.

GBrain gives you back the answer, with sources:

Alice runs engineering at Acme (a series-B fintech). You last spoke
on April 22 in a quick pricing chat. Three things are still open
from that conversation:

1. She owes you the security review for the new tier
   (deadline was May 1; no update since).
2. You committed to pricing for a 500-seat tier
   (you sent it April 25; no response yet).
3. She mentioned they're hiring a CISO; you said you'd intro
   someone from your network.

Heads up: nothing's been added to the brain about Alice or Acme
since April 22, six weeks ago. She may have replied through email
or Slack DM, channels the brain doesn't see. Worth asking her to
catch up before assuming any of this is still current.

Every claim has a source page behind it. The "heads up" at the end tells you what the brain doesn't know yet, so you can ask Alice about it directly instead of being surprised. The brain just did your meeting prep.

This is the difference between a search engine and a brain. Search finds the pages. The brain reads them for you and writes the answer.

Two ways to query your brain

Raw retrieval (what most personal-knowledge tools ship) and a synthesis layer that gives you an actual answer. They serve different jobs.

# raw retrieval: top pages by hybrid score, no answer-generation call
gbrain search "who's working on AI agents at portfolio companies?"

# brain layer: synthesized answer with citations and gap analysis
gbrain think "who's working on AI agents at portfolio companies?"

gbrain search returns the top retrieved pages, ranked by hybrid scoring (vector + keyword + RRF + source-tier boost + reranker). Use it when you want raw material to skim: agent context windows, citation lookups, finding a specific quote.

Configured embedding and reranking providers can still receive text and charge for retrieval. Keyless keyword search needs no model API; synthesis requires a configured chat capability. See memory boundaries.

Search also tells you when its results are incomplete because projections are still rebuilding or a bounded vector scan ran short. Ask your agent "Check whether my search index is ready"; see search readiness and recovery before treating an empty result as proof that a page is missing.

gbrain think runs the same retrieval, then composes a synthesized answer across the results with explicit citations to the source pages AND an honest note on what the brain doesn't know yet. The gap analysis is the differentiator: the answer tells you when a page is stale, when a claim is uncited, when two pages contradict each other, when there's a hole you should fill.

Say to your agent: "What do we know about acme-example?" — "Tell me about alice-example before my meeting tomorrow" — "Search for who's working on AI agents." Your agent routes these to the brain automatically; you never type the commands yourself.

Why it compounds. Pair the brain layer with find_trajectory and you get answers like "how have the company's metrics changed AND what does the team look like right now AND what did they promise / share AND when did we last meet AND what's the value-add I can offer here": well-scored, well-cited, in one shot. That's the strategic moat. That's why building a 150K-page brain is worth the effort.

gbrain agent run "..." exposes the same surface to a sub-agent through the Minions queue, with crash-safe two-phase persistence. Same answers, durable.

How to get data in

Start with an explicit fact or a notes folder; opt into connectors, capture, and enrichment separately.

Already have a company knowledge repository? Say to your agent: “Connect our existing company brain, preserve its files, and show me the import plan first.” Try gbrain sources demo company-brain without keys or private data, then inspect your committed Markdown with gbrain sources inspect <path> --profile company-brain. The company-brain ingestion guide covers explicit destination approval, typed relationships, and resumable verification. It does not enable embeddings, sharing, schedules, or curation automatically.

Say to your agent: "Remember this with its source" — "What should I import first?"

Data ingestion guide covers files, conversations, connectors, Google data, and capture commands.

Your brain's shape (schema packs)

Most personal-knowledge tools force one fixed layout: their idea of "notes" + "people" + "tags." Drop a Notion export or your own years-old Obsidian vault on top, and the agent doesn't know what a Projects/ folder means or whether Reading/ is people or sources.

gbrain doesn't have a fixed layout. It ships with bundled schema packs and lets you author your own when none fit:

  • gbrain-base-v2 (default) — 15-type DRY/MECE canonical taxonomy (14 canonical + note catch-all): person, company, media, tweet, social-digest, analysis, atom, concept, source, deal, email, slack, writing, project, note. Subtypes/format/origin pushed to frontmatter.
  • gbrain-base (legacy) — the wider 24-type layout. Stays bundled for back-compat; brains on it can upgrade via gbrain onboard --check --explain → gbrain jobs submit unify-types --params '{"target_pack":"gbrain-base-v2","apply":true}' (omit "apply":true for a dry-run preview — that is the default).
  • gbrain-recommended — extends gbrain-base with the 13 additional directories from docs/GBRAIN_RECOMMENDED_SCHEMA.md (source, place, trip, conversation, personal, civic, project, etc.). Activate with gbrain schema use gbrain-recommended.
  • Your own pack — gbrain schema detect clusters your actual filesystem into proposed types, gbrain schema suggest runs an LLM pass over them, and gbrain schema review-candidates --apply promotes the ones you like. Three commands and the brain knows your shape. Authoring a successor pack (declares migration_from: so existing brains can opt in): see docs/architecture/pack-upgrade-mechanism.md.
gbrain schema active                # which pack is running, which tier set it
gbrain schema list                  # bundled + installed packs
gbrain schema detect                # propose types matching your filesystem
gbrain schema suggest               # LLM-refined proposals on top of detect
gbrain schema review-candidates     # human gate: promote / rename / ignore
gbrain schema use my-pack           # activate

Say to your agent: "My schema isn't matching my notes — propose new types from my corpus" — "Add a page type for lab results to my brain's schema." The schema-author skill runs the detect → suggest → review flow for you.

The active pack threads through every read + write path: parseMarkdown infers page type from the pack's path prefixes; whoknows scopes expert routing to types declared expert_routing: true; extract_facts runs only on extractable: true types. The retained search-cache key includes the pack name + version, but semantic result reuse is temporarily disabled. Switch packs and the brain re-interprets itself; switch back and nothing's lost.

Seven-tier resolution chain (per-call flag → env var → per-source DB key → brain-wide DB key → gbrain.yml → ~/.gbrain/config.json → gbrain-base default). Full reference + authoring guide: docs/architecture/schema-packs.md.

Tutorials

Step-by-step walkthroughs for getting the most out of GBrain. Each one takes you from zero to a working outcome, with concrete commands and real numbers.

  • Set up your personal AI agent + brain from zero — the canonical full-stack install. Two GitHub repos, a Telegram bot, AlphaClaw on Render, OpenClaw + GBrain + Supabase. End-to-end in about 2 hours.
  • Set up GBrain as your company brain — federated, multi-user, OAuth-scoped institutional memory for a 10-50 person team. About 90 minutes end-to-end.
  • Auto-improve a skill with gbrain skillopt — treat a SKILL.md as a trainable parameter. Generate a starter benchmark straight from the skill with --bootstrap-from-skill (or write your own), strengthen the judges, then watch the optimizer propose edits and keep only the ones that measurably score higher. ~20 minutes, ~$1 in API calls. Flag + cost + safety reference: docs/guides/skillopt.md.

More walkthroughs in progress: connecting an existing agent (Claude Code, Cursor, OpenClaw, Hermes) to a GBrain memory layer; setting up GBrain for VC dealflow with founder scorecards and meeting prep; migrating an existing Notion or Obsidian vault; indexing a codebase as a queryable code brain. Full tutorial index: docs/tutorials/.

Want to see a tutorial that isn't here yet? Open an issue describing the workflow you want documented.

What it does (the loop)

  signal   →   search   →   respond   →   write   →   auto-link   →   sync
  (every    (brain-first  (informed     (page +    (typed edges     (cron
  message)  retrieval)    by context)   timeline)  + backlinks)     keeps fresh)
  • Signal detector, after you opt in, captures durable ideas and entity mentions from substantive messages. Explicit remembering works without automatic capture; paid enrichment is a separate choice.
  • Brain-first lookup before any external API call. The cheapest, fastest, most personal information source you have.
  • Auto-link extracts graph links for trusted local page writes. No LLM calls; pure pattern matching on page references such as [[people/alice-example]]. Unresolved extracted facts keep their provenance without inventing a backing page.
  • Cron-driven enrichment runs while you sleep: dedup people pages, fix citations, score salience, find contradictions, prep tomorrow's tasks.

The whole loop is described in docs/architecture/topologies.md with diagrams.

Say to your agent: "Did upkeep run?" (your agent's open gbrain serve runs the free upkeep while it is idle; gbrain maintain --schedule adds a timer for a brain no agent opens) — "Run dream" — "Did the dream cycle run?"

Capabilities

GBrain combines keyword and semantic retrieval, typed graph traversal, optional cited synthesis, background jobs, and curated agent skills.

Say to your agent: "What search mode am I running?" — "Who works at acme-example?" — "What does my brain know about this project?"

Capability reference keeps the commands, benchmark scope, cost controls, and feature-specific guides.

Integrations

Data flowing into the brain. Each integration is a recipe — markdown + setup hints — that ships in recipes/ and is discoverable via gbrain integrations list. Say to your agent: "Set up voice calls into my brain" — "Wire my email and calendar into the brain" — your agent reads the recipe and walks the setup with you.

  • Voice: talk to your brain from a browser or phone with recipes/agent-voice.md (gbrain integrations install agent-voice); the older Twilio recipe is deprecated. Voice notes and chat transcripts you already have come in as files: put their Markdown in a folder and import it, or bring ChatGPT and Claude exports in with gbrain transcripts ingest (chat connectors).
  • A second folder (for example a company notes folder beside your personal one): gbrain sources add company --path ~/company-notes, then gbrain sync --source company. A plain folder works without Git. On a brain only you use, the new folder joins default search; on a shared brain, gbrain sources federate company adds it. More: multi-source brains.
  • Gmail + Calendar + Contacts (native): the google source kind syncs threads, events, and contacts through your own OAuth client and runs the open-loop engine on top (gbrain waiting). Setup: docs/guides/google-connect.md; recipes: recipes/email-to-brain.md, recipes/calendar-to-brain.md.
  • Meeting notes + Slack channels (native): the meetings source kind (Fireflies first) writes one page per meeting and the slack source kind one page per channel per day, synced on a schedule, on brains with or without a Git repository. Setup: docs/guides/meeting-and-slack-sources.md. The imessage source kind imports Messages from a Mac, one private, owner-only page per chat per day: docs/guides/apple-setup.md.
  • Email + calendar (webhooks): webhook handlers that route to brain signals. docs/integrations/meeting-webhooks.md.
  • Embedding providers: Voyage (new-install default: voyage-4 @ 1024d), OpenAI, OpenRouter, Google Gemini, Azure OpenAI, MiniMax, Alibaba DashScope, Zhipu, Ollama (local), llama.cpp llama-server (local), LM Studio, Together, and LiteLLM proxy. Pricing matrix + decision tree in docs/integrations/embedding-providers.md. Existing vectors are never converted by changing the default; use the explicitly approved embedding migration.
  • Rerankers: Voyage rerank-3-lite hosted (the default unless search.reranker.model is set; on in balanced and tokenmax, same VOYAGE_API_KEY as embeddings; gbrain config set search.reranker.model voyage:rerank-2.5 restores the previous default), plus the llama-server-reranker recipe for fully-local cross-encoder rerank via llama.cpp running Qwen3-Reranker against the same gateway.rerank() seam. Setup walkthrough in docs/ai-providers/llama-server-reranker.md.
  • Credential vault + gateway: gbrain creds manages OAuth and API credentials in a local vault (recipes/credential-gateway.md); agent-side vault-aware secret distribution: docs/integrations/credential-gateway.md.
  • MCP clients: every major MCP client is supported. docs/mcp/ per-client setup.
  • Memorable (procedural memory): optional, off by default. Your brain remembers what happened; Memorable makes your agent remember how — finished sessions become replayable procedures stored on your machine (in a standalone local store, or inside your brain database if you opt in), recalled when a similar task comes back. See the section below, and docs/memorable-agents.md for the agent-facing detail.

Memorable — remember how, not just what (optional)

Memorable stores replayable procedures from coding sessions. Its relay is off by default and requires an explicit disclosure/consent step; it can send redacted traces and query text off-machine. Read the Memorable integration guide for installation, data flow, per-harness limitations, and removal.

Say to your agent: "Explain Memorable's data sharing before enabling it."

Architecture

flowchart LR
    Repo[Markdown brain repos] --> Sync[Sync and parse]
    Sync --> Engine{Brain engine}
    Engine -->|default| PGLite[(PGLite)]
    Engine -->|shared or large| Postgres[(Postgres and pgvector)]
    Agent[AI agent or operator] --> Surface[CLI or MCP]
    Surface --> Ops[Contract-first operations]
    Ops --> Search[Hybrid retrieval]
    Ops --> Graph[Typed graph traversal]
    PGLite --> Search
    Postgres --> Search
    PGLite --> Graph
    Postgres --> Graph
    Search --> Synthesis[Synthesis and gap analysis]
    Graph --> Synthesis
    Synthesis --> Answer[Cited answer]
Loading

Two engines, one contract. PGLite (Postgres 17 via WASM, zero-config, default) for personal brains up to ~50K pages. Postgres + pgvector (Supabase or self-hosted) for shared, large or multi-machine brains. Both implement one BrainEngine contract (src/core/engine.ts); CLI and MCP share one op registry.

Canonical files preserve file-backed knowledge. Your brain repo holds the Markdown; the database is an index rebuildable from it, and git deletes become soft-deletes. DB-only pages, unresolved facts, history and operational state need a database backup: where your memory lives, system of record. Publish public subsets, share team mounts, or point a thin client at a colleague's brain. Topologies in docs/architecture/topologies.md.

Two organizational axes (brain ⊥ source). A brain is a database (your personal brain, a team mount you joined). A source is a repo inside that brain. Routing uses .gbrain-source dotfiles and a 6-tier precedence chain. Diagrams in docs/architecture/brains-and-sources.md.

Why the graph matters. Vector search finds similar text; graph retrieval follows stored relationships. Extracted edges are evidence to inspect, not proof that a relationship is true. Graph freshness depends on the write path and maintenance described in memory boundaries. Deep dive: retrieval architecture; entity recall.

Troubleshooting

Start with gbrain doctor. For database access failures, use gbrain engine status --probe and gbrain db-repair before changing configuration.

Say to your agent: "Check my brain health and show me the repair plan before changing anything."

Troubleshooting reference covers installation recovery, PGLite startup, embedding dimensions, locks, import failures, and sync.

Docs

  • docs/INSTALL.md — every install path, end to end
  • docs/guides/bootstrap.md — the persistent-personal-agent bootstrap contract (interview, identity files, hooks, private repo, security posture, uninstall), plus local harness mode (gbrain bootstrap harness) for wiring framework-spawned Claude Code/Codex sessions to a running serve
  • Anatomy of a page — frontmatter, timeline, facts; per-client facts
  • docs/what-schemas-unlock.md — why schemas matter: 7 killer use cases, the structural argument for typed page kinds, the agent-co-curates pattern
  • docs/schema-author-tutorial.md — 5-minute walkthrough: fork the bundled pack, add a custom type, backfill existing pages, prove the wiring via gbrain whoknows
  • docs/architecture/ — system design, topologies, retrieval theory
  • docs/guides/ — how-to runbooks (google connect, open loops, sub-agent routing, minion deployment, skill development, brain-first lookup, idea capture, diligence ingestion)
  • docs/integrations/ — connecting external data sources (voice, email, calendar, embedding providers)
  • MCP task guide — deployment and per-client setup (Claude Desktop, Code, Cursor, ChatGPT, Perplexity, Cowork)
  • MCP administration — owner dashboard access, client registration, OAuth, permissions, and token recovery
  • Evals and research — methods and results
  • Rust engine plan — proposed design for a third storage engine, not built yet; its research maps and review record
  • docs/ethos/ — philosophy (thin harness, fat skills, markdown as recipes, origin story)
  • AGENTS.md — entry point for non-Claude agents
  • CLAUDE.md — entry point for Claude Code (deep operating context)
  • CONTRIBUTING.md — contributor guide, test discipline, eval-capture mode
  • SECURITY.md — install-path trust model, self-update integrity, automated scanning, OAuth threat model, hardening defaults

Contributing

Run bun run test for the fast loop, bun run verify for the pre-push gate, bun run ci:local to run the full Docker-backed CI stack locally. Detailed test discipline in CONTRIBUTING.md.

Outside documentation changes can be merged as they are. Code fixes we take are rebuilt on current master with the author credited as co-author (Co-Authored-By: trailers), and the original PR is closed with a link to the one that landed it; changes we don't take are closed with a note saying why. What to expect, and what makes a fix easy to take: How an outside pull request is handled. We credit every accepted contribution in CHANGELOG.md. To browse community reports without our agents' own issues, use the community issues search.

If you find a bug or want a feature: open an issue first. Quick fixes (typo, doc bug, obvious regression) can go straight to a PR. Anything touching schema, retrieval ranking, MCP protocol, or the security boundary needs a design discussion in the issue first.

License + credit

MIT. I built GBrain to run my OpenClaw and Hermes deployments — the production brain behind my AI agents.

Origin story: docs/ethos/ORIGIN.md.

Community PR contributors are credited in CHANGELOG.md per release. Attribution for the retired provider's historical embedding and reranker integration remains in Git at 6040075c6cb95be5881cc2e1b76ef7d71f4e5d29. Voyage AI for the asymmetric-encoding recipe template. Ramp Labs for the search quality improvements lineage.

View on GitHub

Recent activity

commits and pull requests

Releases and announcements

812 total
  1. v0.60.740.0v0.60.740.0Nov 18, 2026pre-release33 downloads

    - An agent job a starter client submits is now confined to the starter tool surface, so its tool calls cannot read soft-deleted pages either (#9695) - A remote MCP client on the starter tool surface can no longer pass parameters its tool list leaves out, so its direct tool calls cannot read soft-deleted pages; connector imports now write their trust marker into each new page (#9695) - Code callers, callees and chunk edges now come back in a fixed order on PGLite and Postgres (#9694) - The ingest log and the eval capture failure list now return rows written in the same millisecond newest first on every engine (#9694) - Ontology conflicts, raw enrichment data and page files now come back in a fixed order on PGLite and Postgres (#9694) - `gbrain salience` now lists pages with the same score in a fixed order: by source, then by slug (#9694) - Importing a file, hybrid search and the background-cycle lock now reach the database through named engine methods instead of raw SQL, with the same results on PGLite and Postgres (#9694) **An agent job a starter client submits is now confined to the starter tool surface, so its tool calls cannot read soft-deleted pages either.** <!-- behavior-c

  2. v0.60.739.0v0.60.739.0Nov 18, 2026104 downloads

    Stable release v0.60.739.0: every change since the previous stable release, v0.60.737.0, newest first. What changed since v0.60.737.0: 23 changes. Needs you (2): - gbrain setup <harness> --serves several on a brain that serves one person and already holds pages no rule or readable_by restricts (a journal, DMs, chat, mail, the conversation archive) now refuses with setup_history_choice_required and wr… - gbrain access serves several --labelled-only on a brain that has the company source and no owner now stops with a BLOCKED company/ line and writes nothing, where it used to label the members. Behavior changes (8): - `gbrain extract-conversation-facts` now keeps a name tag on a fact about a person or company that has no page, instead of storing the fact with no entity (the 0.60.162.0 rule, which still applies to every other writer). - gbrain setup <harness> --serves several (and gbrain access serves several --owner <id>) now names the brain owner when the brain has none: it adds a member from --owner <id>, or by default from your login name as a member id, and runs gbra… - gbrain auth create <name> --member <id> without --scopes now mints a key with read and write only. - gbrain s

  3. v0.60.738.0v0.60.738.0Nov 18, 2026pre-release10 downloads

    - A small macOS helper that gives gbrain read-only access to your Messages history now lives in `apple/helper/`. Nothing in gbrain calls it yet (#9620) - `gbrain dedupe --preview` shows which person and company pages are likely the same person or company, with the evidence, and changes nothing (#9680) - A long Gmail backfill on a managed brain now keeps its progress as mail is saved, so a backfill that used to restart from the same spot every sync finishes (#9687) - Pull-request pushes no longer wait for a macOS runner, and a master push that reuses a passed full run skips its macOS security check (#9658) - Mention links now go to the person or company a page's frontmatter names, not to a thin page that only carries the name as its title (#9674) - `gbrain dream --input` with no database now fails instead of reporting success, a second dream run on the same day keeps the first run's summary links, and Slack day pages pick up a missing user's name within a day (#9623) - Dependency scans no longer fail on the picomatch advisory GHSA-fc5q-39xc-vjpf in the admin UI's build tooling, until 2026-12-17 (#9661) - A full test run whose failed jobs were re-run now still lists every test file i

  4. v0.60.737.0v0.60.737.0Nov 17, 202691 downloads

    Stable release v0.60.737.0: every change since the previous stable release, v0.60.734.0, newest first. What changed since v0.60.734.0: 33 changes. Needs you (2): - `gbrain takes extract --from-pages --dry-run` without `--yes` no longer sends page content to the chat model. - In a managed checkout, gbrain git commit-push --untrack now reads the brain for every file, Markdown and CSV included, to learn which folder the source is rooted in (it used to read the checkout's top-level gbrain.yml, which refused every… Plus 22 fixes and 9 additions. `gbrain doctor --only behavior_changes` lists every change in full. ## [0.60.737.0] - 2026-11-17 **Conversation extraction keeps wishes and preferences again: the extractor no longer asks the model for a slot on every fact.** ### Fixed - Since 0.60.735.0, `gbrain extract-conversation-facts` asked the model for a slot (where a person lives, who employs them or their role) on every fact. That request made it save fewer facts, with wishes, preferences and ideas down about 15%. The main extraction call now sends the prompt and response shape it used before 0.60.735.0, so no new fact carries a slot, and a `--force` re-extraction adds none: skip

  5. v0.60.736.0v0.60.736.0Nov 17, 2026pre-release11 downloads

    - Contributors: the pre-merge check now accepts changes to the macOS helper's files under `apple/helper/`, which build and test only in their own macOS workflow (#9627) - A private fact restated as world and held for the owner's accept stays hidden in more places from callers who cannot read the private fact: `think` leaves it out, the reply to the held write reads like an ordinary save, and a restatement written onto another page about the same entity is held too (#9627) - A private fact restated as world and held for the operator's accept no longer reaches remote callers through page, chunk, search and edit reads: get_page, get_versions, fetch, search, query, search_exact, get_chunks, the entity card and the edit_page diff leave the held row out for callers who cannot read the private fact (#9574) - Link context no longer shows remote callers private or held fact rows: get_backlinks, get_links, traverse_graph (walks and hops), the relationship-chain evidence on search, query and recall results, the entity card, context_pack and delta's belief changes leave that text out for callers who may read only world facts, and context_pack's always-loaded core block leaves held rows out for

Code frequency

additions and deletions
+194.5K-194.5KWeek of 2026-04-05: +194,525 linesWeek of 2026-04-05: -138,367 linesWeek of 2026-04-12: +39,833 linesWeek of 2026-04-12: -1,750 linesWeek of 2026-04-19: +66,354 linesWeek of 2026-04-19: -11,834 linesWeek of 2026-04-26: +44,778 linesWeek of 2026-04-26: -986 linesWeek of 2026-05-03: +69,415 linesWeek of 2026-05-03: -4,781 linesWeek of 2026-05-10: +66,519 linesWeek of 2026-05-10: -2,024 linesWeek of 2026-05-17: +153,771 linesWeek of 2026-05-17: -10,116 linesWeek of 2026-05-24: +98,259 linesWeek of 2026-05-24: -7,575 linesWeek of 2026-05-31: +42,688 linesWeek of 2026-05-31: -4,801 linesWeek of 2026-06-07: +16,564 linesWeek of 2026-06-07: -1,851 linesWeek of 2026-06-14: +13,051 linesWeek of 2026-06-14: -755 linesWeek of 2026-06-21: +2,693 linesWeek of 2026-06-21: -160 linesWeek of 2026-06-28: +3,776 linesWeek of 2026-06-28: -115 linesWeek of 2026-07-05: +581 linesWeek of 2026-07-05: -92 linesWeek of 2026-07-12: +11,897 linesWeek of 2026-07-12: -1,223 linesWeek of 2026-07-19: +35,307 linesWeek of 2026-07-19: -7,893 linesWeek of 2026-07-26: +26,991 linesWeek of 2026-07-26: -2,682 linesWeek of 2026-08-02: +14,406 linesWeek of 2026-08-02: -4,318 linesWeek of 2026-08-09: +152,591 linesWeek of 2026-08-09: -10,761 linesWeek of 2026-08-16: +194,501 linesWeek of 2026-08-16: -30,866 linesWeek of 2026-08-23: +97,044 linesWeek of 2026-08-23: -5,517 linesWeek of 2026-08-30: +48,769 linesWeek of 2026-08-30: -5,305 linesWeek of 2026-09-06: +62,010 linesWeek of 2026-09-06: -13,621 linesWeek of 2026-09-13: +57,832 linesWeek of 2026-09-13: -13,091 linesWeek of 2026-09-20: +92,899 linesWeek of 2026-09-20: -19,449 linesWeek of 2026-09-27: +45,441 linesWeek of 2026-09-27: -3,582 linesApr 5, 2026Sep 27, 2026
+1.7M lines added, -303.5K removed over the last year.

Commits per week

last 52 weeks
50220Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 0 commitsWeek of 2026-03-29: 0 commitsWeek of 2026-04-05: 103 commitsWeek of 2026-04-12: 35 commitsWeek of 2026-04-19: 60 commitsWeek of 2026-04-26: 46 commitsWeek of 2026-05-03: 79 commitsWeek of 2026-05-10: 82 commitsWeek of 2026-05-17: 110 commitsWeek of 2026-05-24: 109 commitsWeek of 2026-05-31: 45 commitsWeek of 2026-06-07: 38 commitsWeek of 2026-06-14: 18 commitsWeek of 2026-06-21: 4 commitsWeek of 2026-06-28: 4 commitsWeek of 2026-07-05: 4 commitsWeek of 2026-07-12: 137 commitsWeek of 2026-07-19: 568 commitsWeek of 2026-07-26: 275 commitsWeek of 2026-08-02: 45 commitsWeek of 2026-08-09: 217 commitsWeek of 2026-08-16: 75 commitsWeek of 2026-08-23: 119 commitsWeek of 2026-08-30: 51 commitsWeek of 2026-09-06: 38 commitsWeek of 2026-09-13: 36 commitsWeek of 2026-09-20: 52 commitsWeek of 2026-09-27: 1017 commitsWeek of 2026-10-04: 4684 commitsWeek of 2026-10-11: 5022 commitsWeek of 2026-10-18: 4306 commitsWeek of 2026-10-25: 3111 commitsWeek of 2026-11-01: 2307 commitsWeek of 2026-11-08: 3857 commitsWeek of 2026-11-15: 378 commitsNov 23, 2025Nov 15, 2026
27K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 87 commitsSun 1:00 — 68 commitsSun 2:00 — 138 commitsSun 3:00 — 63 commitsSun 4:00 — 92 commitsSun 5:00 — 45 commitsSun 6:00 — 55 commitsSun 7:00 — 43 commitsSun 8:00 — 23 commitsSun 9:00 — 32 commitsSun 10:00 — 23 commitsSun 11:00 — 34 commitsSun 12:00 — 33 commitsSun 13:00 — 33 commitsSun 14:00 — 30 commitsSun 15:00 — 31 commitsSun 16:00 — 63 commitsSun 17:00 — 136 commitsSun 18:00 — 150 commitsSun 19:00 — 90 commitsSun 20:00 — 95 commitsSun 21:00 — 67 commitsSun 22:00 — 67 commitsSun 23:00 — 75 commitsMon 0:00 — 109 commitsMon 1:00 — 135 commitsMon 2:00 — 61 commitsMon 3:00 — 37 commitsMon 4:00 — 36 commitsMon 5:00 — 56 commitsMon 6:00 — 66 commitsMon 7:00 — 50 commitsMon 8:00 — 57 commitsMon 9:00 — 159 commitsMon 10:00 — 71 commitsMon 11:00 — 62 commitsMon 12:00 — 44 commitsMon 13:00 — 47 commitsMon 14:00 — 66 commitsMon 15:00 — 70 commitsMon 16:00 — 91 commitsMon 17:00 — 96 commitsMon 18:00 — 122 commitsMon 19:00 — 78 commitsMon 20:00 — 83 commitsMon 21:00 — 156 commitsMon 22:00 — 112 commitsMon 23:00 — 108 commitsTue 0:00 — 73 commitsTue 1:00 — 117 commitsTue 2:00 — 118 commitsTue 3:00 — 83 commitsTue 4:00 — 48 commitsTue 5:00 — 41 commitsTue 6:00 — 53 commitsTue 7:00 — 36 commitsTue 8:00 — 28 commitsTue 9:00 — 27 commitsTue 10:00 — 49 commitsTue 11:00 — 43 commitsTue 12:00 — 45 commitsTue 13:00 — 31 commitsTue 14:00 — 69 commitsTue 15:00 — 50 commitsTue 16:00 — 59 commitsTue 17:00 — 59 commitsTue 18:00 — 36 commitsTue 19:00 — 43 commitsTue 20:00 — 51 commitsTue 21:00 — 85 commitsTue 22:00 — 81 commitsTue 23:00 — 107 commitsWed 0:00 — 90 commitsWed 1:00 — 123 commitsWed 2:00 — 83 commitsWed 3:00 — 94 commitsWed 4:00 — 47 commitsWed 5:00 — 25 commitsWed 6:00 — 47 commitsWed 7:00 — 42 commitsWed 8:00 — 58 commitsWed 9:00 — 49 commitsWed 10:00 — 30 commitsWed 11:00 — 41 commitsWed 12:00 — 11 commitsWed 13:00 — 28 commitsWed 14:00 — 21 commitsWed 15:00 — 58 commitsWed 16:00 — 64 commitsWed 17:00 — 74 commitsWed 18:00 — 114 commitsWed 19:00 — 53 commitsWed 20:00 — 59 commitsWed 21:00 — 71 commitsWed 22:00 — 45 commitsWed 23:00 — 46 commitsThu 0:00 — 47 commitsThu 1:00 — 53 commitsThu 2:00 — 39 commitsThu 3:00 — 50 commitsThu 4:00 — 89 commitsThu 5:00 — 91 commitsThu 6:00 — 95 commitsThu 7:00 — 75 commitsThu 8:00 — 85 commitsThu 9:00 — 64 commitsThu 10:00 — 64 commitsThu 11:00 — 62 commitsThu 12:00 — 79 commitsThu 13:00 — 106 commitsThu 14:00 — 64 commitsThu 15:00 — 67 commitsThu 16:00 — 55 commitsThu 17:00 — 155 commitsThu 18:00 — 104 commitsThu 19:00 — 71 commitsThu 20:00 — 81 commitsThu 21:00 — 97 commitsThu 22:00 — 107 commitsThu 23:00 — 81 commitsFri 0:00 — 100 commitsFri 1:00 — 71 commitsFri 2:00 — 62 commitsFri 3:00 — 66 commitsFri 4:00 — 53 commitsFri 5:00 — 42 commitsFri 6:00 — 30 commitsFri 7:00 — 36 commitsFri 8:00 — 72 commitsFri 9:00 — 70 commitsFri 10:00 — 57 commitsFri 11:00 — 38 commitsFri 12:00 — 53 commitsFri 13:00 — 48 commitsFri 14:00 — 37 commitsFri 15:00 — 49 commitsFri 16:00 — 138 commitsFri 17:00 — 75 commitsFri 18:00 — 91 commitsFri 19:00 — 202 commitsFri 20:00 — 134 commitsFri 21:00 — 95 commitsFri 22:00 — 72 commitsFri 23:00 — 97 commitsSat 0:00 — 88 commitsSat 1:00 — 65 commitsSat 2:00 — 60 commitsSat 3:00 — 92 commitsSat 4:00 — 85 commitsSat 5:00 — 120 commitsSat 6:00 — 75 commitsSat 7:00 — 86 commitsSat 8:00 — 70 commitsSat 9:00 — 44 commitsSat 10:00 — 69 commitsSat 11:00 — 57 commitsSat 12:00 — 36 commitsSat 13:00 — 44 commitsSat 14:00 — 25 commitsSat 15:00 — 51 commitsSat 16:00 — 106 commitsSat 17:00 — 139 commitsSat 18:00 — 145 commitsSat 19:00 — 184 commitsSat 20:00 — 147 commitsSat 21:00 — 88 commitsSat 22:00 — 78 commitsSat 23:00 — 93 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits13,661 (85%)
Community commits2,447 (15%)

16,108 commits in total over the last year.

DateListRankStars gained
Nov 10, 2026daily#6+215
Nov 9, 2026daily#6+215
Apr 13, 2026daily#14+177
Apr 12, 2026daily#11+414
Apr 11, 2026daily#4+640
Apr 10, 2026daily#11+314
  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • freeCodeCamp/freeCodeCamp

    freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming, and computer science for free.

    459.4K stars · TypeScript

  • openclaw/openclaw

    The AI that really does things. Any OS. Any Platform. The lobster way. 🦞

    394.9K stars · TypeScript

  • anomalyco/opencode

    The open source coding agent.

    228.3K stars · TypeScript

  • n8n-io/n8n

    Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.

    211.6K stars · TypeScript

  • firecrawl/firecrawl

    Knowledge infrastructure to make your agents smarter. Search, scrape and access 550+ data providers through one API.

    205.3K stars · TypeScript