GBrain for beginners: turning notes into an agent-readable brain
GBrain for beginners: turning notes into an agent-readable brain
Most note-taking systems assume the reader is you.
That worked when notes were mostly personal memory: meeting notes, research scraps, half-written essays, transcripts, screenshots, and reminders to future-you. But once agents start operating across those notes, the old pile-of-markdown model gets weird fast.
An agent can read a file if you point to it. That is not the same as understanding what the file is, where it belongs, whether it is private, whether it can be cited, or which folder is the source of truth.
GBrain is my attempt to make the mess legible.
The quick skim
- Brain = database. It is the indexed knowledge store.
- Source = repo or folder inside the brain. It is where the content comes from.
- Obsidian stays human-friendly. GBrain adds an agent-readable layer.
- The goal is not search alone. The goal is safer, more reliable agent work over personal knowledge.
The problem GBrain solves
Markdown is beautiful because it is simple. It is also chaotic because it is simple.
A vault can hold polished public posts, private notes, work-in-progress ideas, source packets, investment memos, transcripts, and project logs. Humans can navigate that with memory and vibes. Agents need stronger rails.
Without those rails, they make predictable mistakes:
| Failure | What it looks like |
|---|---|
| Wrong source | Reading an old copy instead of the canonical note |
| Privacy leak | Treating private notes as publishable material |
| Bad citation | Quoting a draft as if it were evidence |
| Lost context | Missing related notes because filenames differ |
GBrain gives agents a structure for asking: which brain, which source, which note, what citation, what operation?
How to think about the architecture
The cleanest beginner model is:
Obsidian is the writing surface. GBrain is the operating layer.
Obsidian remains where I write and edit. Git remains the durable version trail. Knowledge OS is the public site. GBrain sits beside those tools and makes the knowledge base queryable, chunked, embedded, and usable by agents through a CLI or MCP interface.
The key distinction is small but important:
- Brain: the database the agent is talking to
- Source: the repo, vault, or content stream inside that database
That separation matters when one person has multiple vaults, one public site, generated notes, and project logs. It prevents the agent from treating everything as one undifferentiated blob.
Why this matters for agents
The dream is not "better search." Better search is table stakes.
The real dream is workflow safety. An agent should be able to answer questions, draft posts, link related material, cite sources, and update notes without constantly asking you to babysit paths and context.
That matters because personal knowledge work has a trust boundary. Some notes are raw. Some are publishable. Some are source material. Some are conclusions. Some are old enough that they should be treated as archaeological evidence rather than current truth. A useful agent has to respect those differences instead of treating every markdown file as equal text.
That requires more than embeddings. It requires operating rules: what counts as a source, how to route a query, when to cite, when to write, and when to stop.
In my setup, GBrain is part of a bigger loop:
- Notes accumulate in Obsidian.
- GBrain indexes and routes them.
- Hermes agents can read and act on them.
- Knowledge OS publishes the public layer.
- The whole system gets easier to query over time.
The mental model
A normal vault remembers what you wrote.
An agent-readable brain remembers enough structure for software to work with it.
That is the shift. The notes are no longer just a personal archive. They become infrastructure: searchable, citeable, routable, and eventually operable by agents that can help maintain the knowledge system itself.