GBrain: Traceable shared memory for OpenClaw and Hermes agents
Traceable shared memory for OpenClaw, Hermes, and team agents, with synthesis and typed-graph retrieval beyond plain chunks.
GitHub garrytan/gbrain Updated 2026-11-10 Branch master Stars 32.2K Forks 4.8K
TypeScript Shell AI agent memory Knowledge graph MCP Supabase OpenClaw Hermes

🧭 Decision Guide

Why trending now: Cannot be determined from the materials.

Try it if you

  • You already use OpenClaw or Hermes and want multiple agents to share sourced facts.
    README section “Give the agent you already use a memory you control”: it supports explicit facts, sources, corrections, and withdrawal.
  • Your 10–50 person team needs an OAuth-scoped company knowledge base.
    README Tutorials section “Set up GBrain as your company brain” explicitly describes federated, multi-user, OAuth-scoped memory for a 10–50 person team.
  • You need relationship queries about people and companies instead of only text chunks.
    README section “A typed knowledge graph”: it supports breadth-first graph walks and reports production BrainBench R@5 of 0.7241.
  • You want to optimize an existing SKILL.md and accept about 20 minutes and $1 in API-call costs.
    README Tutorials section “Auto-improve a skill with gbrain skillopt”: it supports `--bootstrap-from-skill` and states about 20 minutes and $1 in cost.

Skip it if you

  • You require local files or shared database credentials to inherently isolate callers.
    The README company-brain section states that these trust boundaries are not isolated by sources, and authorization tests are not a universal no-leak guarantee.
  • Your data cannot be sent to cloud embedding, reranking, extraction, or synthesis providers.
    The README section on “memory boundaries” explicitly says configured cloud providers may receive text.
  • You need a complete database backup rather than a Markdown content export.
    The README explicitly states, “Markdown export is not a full database backup.”
  • You only want an existing agent’s native editable memory and do not need GBrain’s provenance or shared access.
    The README says Muse already has native editable memory, while GBrain adds an explicit, portable record with provenance and shared access.

Requirements

  • The installer is a Shell script for macOS and Linux; the README says to read it before running.
  • The hosted CLI installation example requires Bun 1.4.4+; otherwise Bun must be installed first.
  • The remote-access path using `gbrain mcp expose` depends on Tailscale; cloud agents can additionally use `--funnel`.
  • Always-on enrichment requires separate compute and API configuration; the README also says keyless memory can be used first.
  • The company-brain tutorial targets 10–50 person teams, while the personal full-stack tutorial includes OpenClaw, GBrain, and Supabase.

First step (verbatim from README)

bun install -g github:garrytan/gbrain#stable   # the gbrain CLI only; no local brain

Watch out

  • Grok Bot and Grok Build are different products, as are Muse’s personal agent and Muse Code.
    The product-distinction note after README “Choose your setup.”
  • Remote `put_page` edges arrive through sweeps, maintenance, or `add_link`, not necessarily immediately.
    README section “A typed knowledge graph” describes how remote `put_page` edges arrive.
  • 0.9791 is the `graph-oracle-parse` upper bound, not the product score.
    The clarification of BrainBench numbers in README “A typed knowledge graph.”
  • Hosted installation can keep the MCP entry, while setup instructions write to CLAUDE.md or AGENTS.md.
    The README Install explanation for `gbrain setup --instructions-only`.

Alternatives

  • Hosted GBrain at gbrain.io：Better when you do not want to install or keep a service online; the README calls it “Fastest” and provides a one-command launch.
    README Install
  • Muse native editable memory：Better when you already use Muse and only need its native editable memory, without GBrain’s portable provenance and shared access.
    README paragraph distinguishing Grok Bot, Muse, and their products

Not stated in the README

  • The omitted README sections do not provide complete self-hosting steps, database configuration, or hardware requirements.
  • The materials do not specify supported Node.js, PostgreSQL, or Supabase versions.
  • The materials do not list the exact models or providers supported for semantic search, synthesis, and enrichment.
  • The materials do not state the storage, CPU, memory, or operating cost required for the reported 155,795-page deployment.
  • The materials do not provide the full BrainBench dataset, test configuration, or comparisons with other systems.
  • The materials do not describe the release changes associated with 10 contributors, 5 releases, or the latest version v0.60.631.0.

💡 Deep Analysis

6
It depends I want to validate GBrain with keyword retrieval first and without model API keys. If I later enable embeddings, reranking, extraction, or synthesis, what data will leave my self-hosted environment?
For: A self-hosting developer who wants to validate memory without model API keys but is concerned about sensitive text being sent to embedding, extraction, or synthesis providers

It depends. GBrain supports a keyless basic retrieval path, but enabling advanced model features may send text to configured external providers. Keyless mode also does not mean the harness cannot see recalled content.

  • The README explicitly recommends starting with keyless memory and keyword retrieval, showing that the basic path does not require those model services.
  • Semantic search, reranking, extraction, and synthesis are optional enhancements rather than mandatory components.
  • The README warns that configured cloud embedding, reranking, extraction, and synthesis providers can receive text.
  • Even in keyless mode, the harness model sees recalled memory. Therefore, having no model API key reduces external-service configuration but does not mean that data never enters a model context.
  • README opening: “Start with keyless memory and keyword retrieval”
  • README: “add semantic search, synthesis, and background enrichment when you need them”
  • README: “Configured cloud embedding, reranking, extraction, and synthesis providers can receive text”
  • README: “the harness model sees recalled memory even in keyless mode”
bun install -g github:garrytan/gbrain#stable   # the gbrain CLI only; no local brain
Not stated in the README：The README does not list data-retention, training-use, region, or encryption policies for each model provider.；It does not state whether every embedding, reranking, extraction, and synthesis step can use local models.
Yes My main queries concern relationships among people, companies, and deals rather than simple text similarity. Do GBrain’s knowledge graph and BrainBench results show that it is suitable for this type of relationship retrieval?
For: A knowledge-system developer focused on relationship questions such as who works at which company and using BrainBench R@5 to assess graph retrieval

Yes for relationship-oriented queries, but the benchmark should not be treated as an accuracy guarantee for all question types. GBrain’s graph retrieval is a complementary channel alongside keyword retrieval, semantic retrieval, and synthesis.

  • The README gives “who works at acme-example?” as an example and says the graph uses breadth-first walks that operate in milliseconds on dense clusters.
  • The typed graph extracts supported references from trusted local page writes, while remote page edges can arrive later through sweeps, maintenance, or add_link.
  • On BrainBench relationship questions, relationship retrieval raises production R@5 from 0.6626 to 0.7241, showing a measurable gain for that task class.
  • The README stresses that 0.9791 is the graph-oracle-parse upper bound, not the product score. Missing relations or entity-resolution errors can still require text retrieval.
  • README: “A typed knowledge graph”
  • README: “Ask ‘who works at acme-example?’”
  • README: “walks are breadth-first, milliseconds on dense clusters”
  • README: “relationship retrieval lifts production R@5 from 0.6626 to 0.7241”
  • README: “0.9791 is the `graph-oracle-parse` upper bound, not a product score”
Not stated in the README：The README does not state the BrainBench dataset size, entity-type distribution, test version, or statistical significance.；It does not describe graph accuracy for frequently changing relationships, duplicate names, or conflicting sources.
Yes I want to host the brain on my own computer and let ChatGPT, Cursor, and Grok Bot access it externally. Should I use Tailscale or MCP exposure with Funnel, and is GBrain suitable for this connection model?
For: A developer using ChatGPT, Cursor, and Grok Bot who wants those clients to access one brain hosted on local hardware through Tailscale or Funnel

Yes, with an important distinction: the connection method depends on whether the client can join your Tailscale network. GBrain natively supports remote MCP exposure from a local brain and separates tailnet access from public Funnel access for cloud agents.

  • The README provides gbrain mcp expose, which publishes the brain over the Tailscale tailnet and keeps it running.
  • For cloud agents such as Grok Bot, Muse, and ChatGPT, the README says to add --funnel, so those clients do not need to join the local network.
  • Project insights list MCP, Tailscale, optional Funnel, OAuth, and private-machine connections as separate trust paths.
  • Remote source filtering is not equivalent to full host isolation. Local files and shared database credentials remain separate trust boundaries, so each client and credential path must be checked before public exposure.
  • Choose your setup: “One command publishes it over MCP on your Tailscale tailnet”
  • README command: `gbrain mcp expose`
  • Choose your setup: “add `--funnel` for cloud agents such as Grok Bot, Muse and ChatGPT”
  • README: “Local files and shared database credentials are a different trust boundary”
gbrain mcp expose
Not stated in the README：The README does not specify the current version requirements of ChatGPT, Cursor, and Grok Bot for remote MCP, OAuth, or Funnel.；It does not document default network restrictions, rate limits, or intrusion protection when using Funnel.
Yes I already use Codex and Claude Code, and I do not want to migrate to a new personal agent or private repository. Is GBrain suitable for giving both agents shared long-term memory?
For: A developer using Codex or Claude Code who wants portable memory without replacing the existing agent identity

Yes. GBrain is suitable because it decouples the memory layer from agent identity and supports sharing sourced facts across agents.

  • The README lists “Add GBrain to my existing agent” as the recommended setup and explicitly says that no new personal-agent identity or private repository is required.
  • Codex and Claude Code both have dedicated connection tutorials and can connect through MCP while retaining their existing clients.
  • The basic path starts with keyless keyword retrieval; semantic search, synthesis, and background enrichment are optional additions.
  • Durable preferences and facts can be shared across agents, while transient task state and harness configuration remain local. It is therefore better for durable knowledge than for synchronizing every runtime detail between agents.
  • Choose your setup: “Add GBrain to my existing agent — recommended”
  • Choose your setup: “No new personal-agent identity or private repository is required”
  • README: “Durable preferences and facts can be shared across agents; transient task and harness configuration state stay local.”
  • Project insight: the memory layer is decoupled from agent identity; basic keyword retrieval needs no model key
bun install -g github:garrytan/gbrain#stable   # the gbrain CLI only; no local brain
Not stated in the README：The README does not specify conflict handling, concurrent-write behavior, or a compatibility matrix for using Codex and Claude Code on the same brain.；It does not state whether visibility for shared facts must be configured item by item.
It depends I lead a 10–50 person team and want multiple agents to share knowledge about people, companies, and projects without exposing personal memories or restricted sources to other members. Is GBrain suitable as a company brain?
For: A technical lead building a shared company brain for a 10–50 person team with separate personal, source, and organizational visibility rules

It depends. GBrain includes authorization mechanisms needed for a company brain, but the README explicitly limits the protection boundary for remote callers. It should not be treated as a universally isolated multi-tenant platform.

  • The README says authenticated remote clients are constrained by source grants, operation grants, and visibility filters, which can control what team members read and which operations they perform.
  • Project insights identify the boundary between personal and organizational memory, source permissions, and shared knowledge as core design concerns, with OAuth and controlled remote MCP support.
  • However, local files and shared database credentials are separate trust boundaries; callers with those privileges may bypass remote source filtering.
  • The README provides no capacity, tenant-isolation, or compliance data for teams of 10–50 people. Adoption therefore depends on accepting responsibility for access control and infrastructure security.
  • README: “Authenticated remote clients are constrained by source and operation grants plus visibility filters”
  • README: “Local files and shared database credentials are a different trust boundary”
  • README: “The authorization tests exercise specific access paths, not a universal no-leak guarantee”
  • Project insight: target users include small teams of 10–50 people
gbrain mcp expose
Not stated in the README：The README does not specify concurrent access, tenant isolation, audit logging, or permission-propagation performance for 10–50 users.；It does not state whether existing enterprise IdPs, SCIM, fine-grained admin roles, or compliance frameworks are supported.
It depends I want to continuously ingest meetings, email, tweets, and voice data, then run 24/7 background enrichment and consolidation like the production deployment described in the README. Is GBrain suitable for this long-running personal knowledge system?
For: An advanced AI user who wants to continuously ingest meetings, email, voice, and social content at a scale comparable to 155,795 pages and 66 cron jobs

It depends. GBrain is architecturally aimed at long-running background memory, but the 155,795-page and 66-cron deployment is the author’s production scale, not a capacity guarantee for your installation.

  • The README describes continuous ingestion of meetings, email, tweets, voice calls, and original ideas, followed by background enrichment, citation repair, and memory consolidation.
  • The project insights state that it can run on your own hardware, database, and keys, making it suitable as a continuously updating daemon.
  • The README explicitly says that always-on enrichment requires separate compute and API configuration; the harness subscription and model API usage are different costs.
  • You must also handle scheduling, retries, logging, spend, and data growth. The README does not provide general capacity or latency limits.
  • README: “155,795 pages, 24,589 people, 5,340 companies, 66 cron jobs running autonomously”
  • README: “My agent ingests meetings, emails, tweets, voice calls, and original ideas”
  • README: “always-on enrichment needs its own compute and API configuration”
  • Project insight: continuous ingestion, enrichment, correction, and consolidation loops
gbrain mcp expose
Not stated in the README：The README does not state the page count, concurrent-task limit, ingestion throughput, or database capacity supported by your hardware.；It does not specify retry semantics, idempotency guarantees, or spending caps for background jobs.

✨ Highlights

  • BrainBench relationship retrieval raises production R@5 from 0.6626 to 0.7241
  • Stores explicit facts with sources, corrections, and withdrawal
  • gbrain skillopt takes about 20 minutes and costs about $1 in API calls
  • The README reports 155,795 pages and 66 autonomous cron jobs

🔧 Engineering

  • Preserves cross-agent memory as explicit facts with sources, corrections, and withdrawal
  • `gbrain mcp expose` publishes a local Brain over Tailscale
  • `gbrain skillopt` generates benchmarks from SKILL.md and keeps measured improvements

⚠️ Risks

  • Local files and shared database credentials do not isolate callers
  • Cloud embedding, reranking, and synthesis providers may receive text
  • Markdown export is not a full database backup
  • Always-on enrichment requires separate compute and API configuration

👥 For who?

  • Developers running OpenClaw or Hermes who need shared, traceable memory
  • Company teams of 10–50 people needing OAuth-scoped memory
  • Agent users working with Codex, Claude Code, or Grok Bot