Early March 2026
OpenClaw proved the idea
I started with OpenClaw to test the basic proposition: a local agent reachable through familiar channels, able to use tools and carry work across sessions.
Hermes
Hermes is the local-first operator I have shaped into a personal mission control center. Work reaches it through Desktop, Telegram threads, Gmail, or scheduled triggers. Obsidian and GBrain preserve the context; tools and human checks turn requests into artifacts I can inspect.
local Mac miniDesktop mission controlTelegram + GmailObsidian + GBrainhuman approval
Current operating systemLocal · inspectable · human-owned
Intake
DesktopMission control
TelegramThreaded intake
GmailAgent inbox
SchedulesProactive checks
Local Mac miniHERMES
Contextload what matters
Routechoose tools or help
Executebuild the artifact
Verifytest the result
Human approval at consequential steps
Memory + tools
ObsidianDurable record
GBrainGraph + retrieval
Browser + APIsExecution
GitHub + filesEvidence
Request → context → action → inspectable artifact → durable memory
How it grew
A useful prototype became a durable operating system.
The system grew around one reliable operator with better ways to receive work, recover context, use tools, and prove what happened.
March 2026
Hermes became the operator
About two weeks later, Hermes felt more intuitive and became the base. Running on a Mac mini, it gave me one place to inspect files, use tools, schedule checks, and resume work.
July 2026
Buzz tested a visible team layer
Buzz was a useful experiment in shared channels and independently addressable agents. In practice, the added coordination created more friction than value, so it remains part of the capstone—not the center of the current system.
Now
Desktop and GBrain deepen it
Hermes Desktop is becoming a customized mission control center. Telegram threads and Gmail extend intake; Obsidian and GBrain make context durable and retrievable.
Current operating system
Hermes is the control plane. Everything else supports the loop.
Different surfaces solve different problems: Desktop for active control, Telegram and Gmail for remote intake, and Obsidian with GBrain for continuity.
HermesOperating now
The accountable operator
Hermes owns intake, context, tool use, follow-up, verification, and the final handoff. Desktop is the primary mission control surface.
IntakeMultiple surfaces
Reachable where work happens
Telegram threads keep remote requests separated by topic. Gmail gives the agent its own address. Scheduled triggers let useful checks start without a prompt.
KnowledgeObsidian + GBrain
Durable, queryable context
Obsidian keeps the human-readable record. GBrain connects and retrieves the relevant projects, people, sources, and decisions when Hermes needs them.
Selective delegation
One owner; specialist help only when it earns its keep.
Hermes can split research, building, communication, or review into bounded assignments. The roles are capabilities—not a permanent theater of agents talking to one another.
HermesAlways accountable
Prioritizes, decomposes, routes, synthesizes, verifies, and closes the loop.
Control planeResearchOn demand
Source recovery, evidence gathering, comparison, and contradiction checks.
Judgment laneBuildOn demand
Code, automation, configuration, prototypes, tests, and implementation.
Execution laneSignalOn demand
Positioning, copy, outreach, briefs, and audience-specific communication.
Communication laneReviewWhen warranted
Independent QA, source audit, risk review, and pre-publication checks.
Independent checkDurable project lanes
Each project keeps its own operating thread.
Files, notes, Git history, and topic-specific threads keep the work resumable without forcing every project into one collaboration tool.
Hermes / project mapCurrent pattern
Project laneRenaissance
Product research, design decisions, implementation, and production QA stay connected.
NotesGitBrowser QA
Project lanePortfolio & positioning
Professional narrative, page updates, evidence, and publication review share one decision trail.
SourcesDraftsReview
Project laneOperations systems
Recurring dashboards and automations run with clear review points and approval boundaries.
SchedulesToolsHuman approval
Memory and retrieval
Obsidian and GBrain form the memory flywheel.
A nightly Dream cycle consolidates email, Telegram threads, and scattered ideas. On Fridays, Hermes runs a broader review across project state, Obsidian, session history, and GBrain.
Obsidian / durable recordOperating now
Human-readable project memory
Notes, decisions, sources, dashboards, and evidence stay in local Markdown. Git history makes automated updates visible and reversible.
SortedCurrent tasks stay with their projects, tested procedures become skills, and personal preferences move into their own memory layers.
InspectableThe record remains readable without a proprietary interface or opaque memory store.
OwnedVerified outcomes flow back into notes instead of disappearing inside a chat session.
GBrain / synthesis + retrievalLive + evolving
Connections without loading the whole vault
GBrain indexes the Obsidian knowledge base, connects related projects, people, sources, and concepts, and gives Hermes a queryable retrieval layer.
ConnectedGraph relationships surface context that folder paths and exact search can miss.
ScopedHermes pulls the smallest useful context instead of flooding each session with the full record.
AdaptiveNew verified work improves both the durable notes and the retrieval layer over time.
01CaptureEmail, Telegram threads, sessions, sources, and project changes enter the review queue.
02SortCurrent work, reusable procedures, and durable preferences move into the right layer.
03ConnectGBrain links related people, projects, sources, and ideas across the vault.
04RetrieveHermes loads only the context needed for the current decision.
05ReviewNightly consolidation and the Friday review keep project state and memory current.
Obsidian keeps the record inspectable. GBrain makes it retrievable. Hermes turns it back into action.
The operating contract
Every assignment ends with inspectable evidence.
Hermes uses another worker only when splitting the work saves more time than coordinating it. Each assignment starts with a definition of done.
01IntakeOne goal arrives through Desktop, a Telegram thread, Gmail, or a scheduled trigger.
02ContextHermes queries GBrain and loads relevant Obsidian evidence, prior decisions, and constraints.
03RouteHermes chooses the right tool or a bounded specialist assignment—only when needed.
04ExecuteTools produce a document, diff, test result, screenshot, live route, or researched decision.
05VerifyHermes or an independent reviewer checks the artifact before delivery and memory refresh.
Each workflow should make the result easier to inspect, safer to ship, and simpler to resume.
Current state
What is in daily use—and what the experiments taught me.
This separates the durable system from a July collaboration experiment that looked promising but added too much coordination overhead.
The working foundation
- Hermes runs locally on a Mac mini; Desktop is the primary mission control surface.
- Telegram threads and a dedicated Gmail address provide remote intake.
- Obsidian holds the durable record; GBrain adds synthesis, graph connections, and retrieval.
- Sessions, schedules, browser work, files, GitHub, APIs, and other tools remain in the loop.
- Important changes are checked with tests, diffs, screenshots, live routes, and human approval.
Where Buzz fits
- Buzz tested shared project channels and separately addressable agent identities in July 2026.
- The visible workspace was useful; the added coordination friction was not.
- It remains an honest capstone chapter, not the primary interface for the current system.
- Its lessons still shape future delegation: fewer agents, tighter scopes, and explicit acceptance checks.
- The full July architecture remains available below as a snapshot of that experiment.
What it enables
What the system does in practice.
The system turns ambiguous requests into finished, checked, and resumable work.
Product and website shipping
Scope, research, copy, code, visual assets, GitHub changes, deploy checks, responsive browser QA, and concise handoff.
Research and decisions
Parallel evidence gathering, primary-source recovery, contradiction checks, structured recommendations, and independent review.
Operations and continuity
Recurring dashboards, scheduled checks, project memory, reminders, and cross-session follow-through.
Operating principle