Context
One person can't be present 24/7 across personal life, a trading book, and a consulting practice. I tried. The shape of the problem isn't time — it's continuity. A human who context-switches every few minutes loses the thread. A system of agents, each with a defined scope and persistent memory, doesn't.
So I built one. Not a chatbot. Not a single mega-prompt with a hundred tools strapped to it. An architected multi-agent system, designed the way you'd design a small org — with leads, specialists, escalation paths, shared knowledge, and a router that decides who handles what.
Hermes is the result. It's been running 24/7 for months. It costs $5–10 a month to operate. Trading Hermes coordinates the markets I trade. Kairos Hermes runs my consulting practice. Personal Hermes handles everything else.
What shipped
Three orchestrators at the top: Personal Hermes runs my life — finances, expenses, future purchases, travel, anything that has to fit around a day job. Trading Hermes runs the book — equities, crypto, Polymarket. The Polymarket leg has its own dedicated stack underneath — see Polymarket for the depth there. Kairos Hermes runs the side consulting practice — client work, ops, scoped to off-hours with hard boundaries so it doesn't bleed into the day job. See Kairos for the practice itself.
Underneath the three, ~35 sub-agents. Each one is scoped narrowly — a single role, a single objective, defined KPIs, a defined escalation path. They don't try to do each other's jobs. The orchestrators route requests by intent and pass messages between sub-agents through an MCP layer that acts as the system's connective tissue.
Each agent has a brain file — a persistent context document defining its voice, scope, what it knows, what it doesn't know, and when to escalate. The brain file is what makes an agent feel like that specific agent across sessions, not just a generic LLM call wearing a name tag.
Underneath that, a RAG knowledge base — the second-brain layer. The agents pull domain context from a wiki I maintain rather than relying on training data alone. The wiki is what makes the agents mine rather than generic.
Trading Hermes runs cron jobs every 2–3 minutes — scanning markets, the Fed calendar, who's speaking when, event flow. Each sub-agent under it has hard stop losses, position-size limits, and escalation rules. Nothing autonomous touches money without the rules saying it can.
The interface is WhatsApp, Telegram, and Discord. I don't talk to Hermes through a custom UI; I talk to it where messages already happen. The orchestrators sit in their own threads. I address them like I'd address people.
The whole stack — three orchestrators, ~35 sub-agents, the router, the wiki, the cron infrastructure — runs on a single VM.
What landed
I don't lose a minute of work. That's the only metric that matters.
A hardware purchase I mentioned to Personal Hermes three weeks ago surfaces again when it's relevant. A market event Trading Hermes was watching for fires while I'm asleep, and the right sub-agent acts inside its risk bounds. Kairos Hermes runs operations in the background — the things that would otherwise consume hours each week.
The lived experience is talking to ~35 agents through three orchestrators across three messaging apps, and having all of it feel coherent rather than chaotic. That coherence is the architecture working.
What I learned
The first lesson is the hardest one and the one I'd undo if I started over: I built behavior before I built infrastructure. I prioritized output and willpower — get something running, prove the concept, iterate later. It didn't scale. Agents without scaffolding don't compose; they collide.
The fix is unglamorous: build the wiki first. Define the brain files first. Write the agent scopes and escalation paths first. Then let the agents act. Behavior comes from scaffolding, not from prompting harder.
The second lesson surprised me. I expected I'd need to escalate to more dangerous autonomy frameworks to get real value — the kind a friend once described as "like giving a monkey a gun." I didn't. Most of Hermes's leverage came from better context routing and narrower agent scopes, not from giving the system more permission to act unsupervised. The wins were architectural, not about autonomy.
Restraint is the feature. Most agent systems fail not because they aren't permissioned enough; they fail because they aren't scoped enough.
Next: a model trained on me. Same architecture, same MCP layer, same agents — but the orchestrators stop being generic LLM calls and start being mine. Lucas-shaped, not assistant-shaped.