Build a Living AI Brain with Obsidian, GitHub, Discord, and Hermes

Most AI assistants fail for a boring reason: every chat becomes a new universe.

They can answer a question, write a draft, or run a command, but the work does not compound. Decisions stay buried in threads. Ideas pile up in bookmarks. Tasks never become execution handoffs. Corrections become apologies instead of system improvements.

A real operator needs a brain, not just memory.

The Always-On Agents approach is simple: give each surface one job, then make the assistant move work through the system.

Always-On Agents preorder

Build an agent that keeps working after you close your laptop.

Start with the free setup checklist. It helps you avoid the usual traps: no place for state, secrets mixed with prompts, automations that send before you approve them, and logs you cannot debug later.

• VPS, Codex, Hermes, and Discord setup steps
• Approval gates before email, tickets, or posts change
• Reusable skills, scripts, and operating checklists
• A preorder path if you want the full walkthrough

Get the free setup checklistReserve preorder — 50% offRead the full public series

The four-layer brain

A useful private AI brain does not require a giant app. It needs a clean operating model.

Hermes sits across those layers as the operator. It can read the current thread, update a scratchpad, create or update an issue, inspect the repo, run checks, and report back with receipts.

The point is not to let an agent do everything. The point is to stop asking the human to reassemble context every time work moves forward.

Why chat is not enough

Chat is great for intent. It is terrible as the only system of record.

A chat thread answers what someone said. It does not reliably answer:

• What did we decide?
• What is still blocked?
• Which task is actually ready to build?
• What should not be touched?
• What verified that the work shipped?
• What should the assistant do differently next time?

That is why the brain needs durable notes and execution tickets. Chat captures motion. Obsidian captures meaning. GitHub captures work.

Obsidian as the durable brain

Obsidian is not the task database in this model. It is the thinking and context layer.

Use it for:

• thread scratchpads;
• project notes;
• workflow doctrine;
• decisions;
• reusable templates;
• weekly reviews;
• sanitized indexes and mirrors.

A starter structure can be very small:

The goal is not a perfect second brain. The goal is a brain your assistant can navigate without guessing.

Thread scratchpads make work resumable

For any important Discord thread, client thread, or project conversation, create a tiny scratchpad.

It should not be a transcript. It should be the current state:

That one file changes the behavior of the assistant. After a restart, it can reconstruct Done, Pending, Blocked, and Next instead of asking you to repeat the whole thread.

GitHub Issues are agent handoff objects

Once work is shaped, it should move into GitHub Issues.

A good AI-ready issue is not a vague reminder. It is an execution contract:

This keeps Markdown from becoming a fake ticket system and keeps issues from becoming vague idea dumps.

Messy input needs routing

Most builders do not have an idea problem. They have a routing problem.

When something comes in from voice, Discord, email, X bookmarks, a meeting, or a random note, classify it before creating work:

1. Archive only.
2. Use now.
3. Incubate.
4. Integrate into a workflow.
5. Research before action.
6. Discard.

Only shaped work should become a GitHub Issue. Raw inspiration belongs in Obsidian until it earns execution.

The closed loop

The simplest useful loop looks like this:

The final update matters. A real operator does not just say “done.” It says what changed, where it changed, how it was verified, and what remains.

Self-healing is the difference

The highest-leverage part of this system is correction handling.

When the assistant makes a mistake, the right response is not just an apology. The right response is to patch the layer that caused the mistake:

• Stable preference or fact: memory or profile note.
• Reusable procedure: skill or workflow.
• Project decision: project note.
• Execution task: GitHub Issue.
• Runtime behavior: script or config, with verification.

That turns a frustrating correction into a permanent system improvement.

Keep the brain separate from the runtime

Do not put everything in Obsidian.

The vault should hold durable, non-secret context:

• workflows;
• scratchpads;
• specs;
• templates;
• decisions;
• sanitized indexes.

The runtime should hold private operational state:

• secrets;
• OAuth tokens;
• sessions;
• logs;
• caches;
• raw outputs;
• local auth files.

That boundary lets the brain be useful without becoming a security mess.

What to build first

If you want to copy this model, start small:

1. Create an AI Brain folder in Obsidian.
2. Add a Brain Index.md.
3. Add a Thread Scratchpad template.
4. Add a GitHub Agent Issue template.
5. Pick one active project thread.
6. Create one scratchpad.
7. Promote one shaped task into a GitHub Issue.
8. Complete one tiny loop and write the verification receipt.

Start with these templates:

• AI Brain Thread Scratchpad Template
• GitHub Agent Issue Template
• AI Brain Idea Capture Template
• AI Brain Recovery Checklist
• Weekly AI Operator Review Template

That is enough to prove the system.

Do not start with a giant automation platform. Start with one durable loop that survives restarts.

How this fits Always-On Agents

The Always-On Agents course starts with the boring foundation: a private VPS, Codex, Hermes, Discord, Google Workspace, and safe approval-gated workflows.

This AI Brain layer is what makes those tools compound.

It gives the agent a place to remember decisions, route ideas, recover context, and improve after mistakes without exposing your private runtime or dumping your whole life into a prompt.

If you want the starter checklists and implementation walkthrough, start with the first three course lessons:

• The AI Brain Operating Model
• Create the Starter Obsidian AI Brain
• Use Thread Scratchpads to Make AI Work Resumable

Then join the Always-On Agents list below for the rest of the implementation path.

Always-On Agents preorder

Build an agent that keeps working after you close your laptop.

Start with the free setup checklist. It helps you avoid the usual traps: no place for state, secrets mixed with prompts, automations that send before you approve them, and logs you cannot debug later.

• VPS, Codex, Hermes, and Discord setup steps
• Approval gates before email, tickets, or posts change
• Reusable skills, scripts, and operating checklists
• A preorder path if you want the full walkthrough

Get the free setup checklistReserve preorder — 50% offRead the full public series