mrkeyoor.com_
Tue 10 Nov 05:42 UTC
AI Toolsevaluationupdated 30 Sept 2026

gbrain review

GBrain is a self-hosted memory layer that lets several AI agents recall the same sourced facts across sessions. It stores knowledge in Markdown and a database, then adds keyword search, optional semantic retrieval, a graph, corrections, withdrawal, and cited synthesis.

+617stars / 7d
Verdict

Our GBrain run installed 295 packages and built in 10 seconds, but its tests were still emitting 4-shard heartbeats when our 900-second limit ended. Use it when sourced, portable agent memory matters enough to justify explicit privacy and backup design. Wait if you need a quiet release cadence or a suite that clears a 15-minute CI gate on this hardware.

We ran it

Lab card: what happened when we ran gbrainScreenshot of gbrain (github.com/garrytan/gbrain)
Install✓ · 87s295 packages · 256 MB
Build✓ · 10s
Tests✗ timed out · 900sran, no count parsed
Repo5966 files~1,098,925 lines of source · 129.6 MB · 9 CI workflows · tests dir

Answers from our run

Does gbrain build from source?

Dependencies installed in 87 seconds (295 packages), and the build succeeded in 10 seconds. We cloned commit b80cad6 into a clean Debian container with 3 CPUs and no project-specific setup.

Do gbrain's tests pass?

We could not finish them: the suite was still running after 15 minutes in our container.

Who should not use gbrain?

Anyone treating a Git-backed Markdown folder as the whole backup: the README says database-only pages, facts, revision history, and operational state need a separate database backup.

What are the alternatives to gbrain?

Mem0, Letta, Graphiti. Our GBrain run installed 295 packages and built in 10 seconds, but its tests were still emitting 4-shard heartbeats when our 900-second limit ended.

Setup3/587-second install; keyless is light, shared deployment is not
Docs5/5Setup, clients, privacy, providers, and recovery are documented
Community5/530,492 stars with October 2 issue and pull-request activity
Maturity3/5Wide feature set, but our 900-second test run never finished

Discussed on

  1. hnGBrain – The memex, built for people who think for a living9 points
  2. hnGarry Tan's GBrain – most important idea of the year5 points
  3. hnGbrain-Evals4 points
  4. hnGarry's Opinionated Agent Brain3 points

Who it’s for

Codex, Claude Code, OpenClaw, or Hermes users who want one memory across agent sessions.
People with Markdown notes who care about sources, corrections, and explicit withdrawal.
Technical teams prepared to define visibility, backup, provider, and retention rules before sharing a brain.
Operators willing to start with local PGLite and move to Postgres when several processes need access.

Who it’s NOT for

Anyone treating a Git-backed Markdown folder as the whole backup: the README says database-only pages, facts, revision history, and operational state need a separate database backup.
Company deployments relying on source boundaries to isolate local callers: the README says local files and shared database credentials are a separate trust boundary.
Privacy-sensitive users who assume keyless memory keeps every word local: the harness model still sees recalled memory, and configured cloud providers can receive text.
Claude Code users who need skill routing to match the current docs: open issue 5858 says frontmatter triggers never reach the model and the promised resolver file is missing.
Release pipelines that require a green suite inside 15 minutes: our test command was still running when the 900-second limit ended.

Setup reality

Our sandbox installed commit b80cad6 in 87 seconds, adding 295 packages and using 256 MB. The build succeeded in 10 seconds. Tests timed out after 900 seconds, so this run did not produce a passing suite.

A basic local brain needs Bun and PGLite; keyword retrieval can start without an API key. Semantic retrieval, reranking, extraction, or synthesis may need Ollama or a configured cloud provider. Remote MCP adds an HTTP service, scoped tokens or OAuth, and a decision about what each caller may read or write.

The current release requires Bun 1.4.0 or newer, and the similarly named npm package is unrelated. PGLite is single-process, while shared or multi-machine use moves to Postgres with pgvector. Git preserves file-backed knowledge, but database-only state needs its own backup.

GBrain gives several agents one source-aware memory

GBrain separates an agent's durable knowledge from any single chat or model. A stored fact can keep its source, be corrected, or be withdrawn, and Codex, Claude Code, OpenClaw, Hermes, and other MCP clients can query the same brain. Keyword search is the starting point. Semantic retrieval, typed graph links, reranking, and cited synthesis are optional layers.

That distinction is useful if you change agents often. The memory lives in Markdown plus a database instead of one vendor's conversation history. Search can return raw pages, while gbrain think composes an answer with citations and says where the stored material has a gap. Provenance and visibility still need attention because a stale or wrongly shared fact remains a bad memory.

Keyless starts with 1 local database and keyword search

The lightest setup uses Bun 1.4.0 or newer, PGLite, and --no-embedding. It needs no Docker and no model API key for keyword retrieval. GBrain warns against the unrelated package named gbrain on npm; the documented install comes from the GitHub repository or a compiled release. A shadowing binary can make every later diagnosis misleading.

Codex can use the GBrain plugin or a direct MCP connection. Claude Code has a plugin, skills, and a local stdio command. The README asks for a real remember, recall, correction, and withdrawal round trip after either setup. A config file alone does not prove that a new conversation will call GBrain and retrieve the saved fact.

What happened when we ran it

Our sandbox installed commit b80cad6 in 87 seconds and added 295 packages. The checkout contained 5,966 files, about 1,098,925 lines of source, and occupied 129.6 MB before installation. Dependencies raised disk use to 256 MB. The build then succeeded in 10 seconds inside an unprivileged container with 3 CPUs, 8 GB of RAM, Node 22, and no secrets.

The test command did not finish before our 900-second cap. Its final output contained heartbeat lines for 4 shards, labeled s1 through s4, from 12m56s through 14m50s. The counters changed slowly, including s2 moving from about 13/495f while the other shards stayed near the start of roughly 491 to 501 files. The tail showed no assertion failure, stack trace, or stated cause, so the defensible finding is a timeout.

The repository had 9 CI workflow files, no Dockerfile, and a tests directory. We measured a successful install and build at b80cad6. We did not measure retrieval quality, provider cost, sync reliability, or how long the complete test suite would eventually need. The timeout cannot be counted as a passing test run.

PGLite serves one process; Postgres serves shared brains

PGLite is the default engine and the README positions it for personal brains up to about 50,000 pages. It is single-process: one live gbrain serve owns the data directory, so a second server cannot open the same brain. Multiple clients can point to one HTTP process, or the operator can move to Postgres and pgvector for concurrent or multi-machine access.

Remote MCP supports read, write, admin, and agent scopes, plus owner-approved OAuth and rate limiting. Authenticated remote clients can be limited by sources, operations, and visibility. Local files and shared database credentials bypass part of that boundary. Test both remote tokens and trusted local callers because a source label alone does not isolate the latter.

Keyless memory can still send recalled text to a model

Keyless means keyword retrieval can work without a separately configured model API. It does not mean every word stays on the machine. The README says the agent harness model sees recalled memory in keyless mode. Configured cloud embedding, reranking, extraction, or synthesis providers can receive text as well. Ollama, llama.cpp, and LM Studio are documented local options.

Saved memories default to brain-wide visibility unless the caller marks them private. Open issue 5857 reports the opposite migration problem on a personal HTTP brain: more than 10,000 legacy private facts remained unavailable to MCP clients, with no documented operator path to widen them. Use a small permission test corpus before importing real email or meeting notes.

Markdown covers only part of the backup

Git can preserve file-backed knowledge and make it inspectable outside GBrain. The README says database-only pages, unresolved facts, revision history, and operational state still need a separate database backup. Markdown export is also described as incomplete. A useful recovery drill must restore the repository and the database.

Open issue 5505 says the backup check can report an empty list of missing Git remotes while connector sources remain unrecoverable under that check. Issue 5852 documents a separate first-sync failure in v0.60.27.0, where a newly seeded skillpack blocks its own Git-backed source until the operator adds an exclusion. Both defects sit directly on the recovery path.

October activity is intense, with 593 open items

GitHub showed 30,492 stars and 593 combined issues and pull requests on October 2, 2026. The last push was October 1, the same day release v0.60.27.0 raised the minimum runtime to Bun 1.4.0. Issues and pull requests were still being opened and updated on October 2. Operators should read migration notes before upgrading an always-on brain.

Open issue 5858 says Claude Code never sees the trigger phrases in GBrain skill frontmatter and that the scaffold omits a resolver file promised by the installer. GBrain is a strong fit for an experienced operator who wants memory to survive the agent. Our 900-second timeout says the same operator should budget real CI time before trusting each release.

Alternatives

ProjectWhat it isPick it when
Mem0 gh↗A memory infrastructure layer for AI agents and applications.pick this instead when you want an application-facing memory service rather than a Markdown-centered personal brain.
LettaA platform for stateful agents that manage and update their own memory.pick this instead when the agent runtime and its memory should come from one platform.
Graphiti gh↗A temporal knowledge-graph framework built for AI agents.pick this instead when time-aware graph retrieval is the main requirement and you will build the agent layer yourself.

Sources

  1. GBrain repository and README
  2. GBrain v0.60.27.0 release
  3. GBrain memory boundaries
  4. Claude Code skill routing issue 5858
  5. HTTP private facts issue 5857
  6. First sync skillpack issue 5852
  7. Backup coverage issue 5505

More ai tools reviews

ooosplat · dexter · oh-my-ppt · Agentero · mini-swe-agent · claude-video · the whole board →