I built a 22-agent AI team to run my business. Then I tore it down and built a smaller composable system in its place.
OpenClaw worked. It was 22 specialized agents orchestrated by 4 directors and 1 CTO (Lurkr), 3 model tiers, workflow-automation orchestrated, ran my real business for ~18 months: lead gen, proposals, invoicing, code review, deployments, content pipeline. Every morning at 9AM Pacific I got standup messages from the 4 directors in Telegram. I read them over coffee. It felt like having a team.
Then I learned that the team I thought I wanted was the team I actually didn't need. The lesson: more agents isn't better. Each new agent is a new maintenance burden, a new failure mode, a new coordination cost. I consolidated to Hermes — composable agents behind a C-suite + VP structure on Ollama Cloud. The OpenClaw era is over. The lessons stuck.
40+
Scheduled Automations
Engineering, Infra, Product, Marketing, Personal
∞
Model Options
Ollama Cloud by task
5
Executive Functions
CTO + C-suite + 3 VPs
0
Migration Downtime
Parallel cutover
The Two Architectures#
OpenClaw was hierarchical — a CEO (me), a CTO (Lurkr), four directors, and specialized agents under each. Hermes is executive-led — a CTO, C-suite skills, VPs for Engineering, Infrastructure, and Product, and agents that compose via delegation. The shape changed; the work didn't.
Lurkr — CTO (OpenClaw era) → now the CTO layer in Hermes
Was Claude Opus 4.6, now glm-5.3-flash on Ollama Cloud
In OpenClaw, Lurkr was a dedicated CTO agent. In Hermes, Lurkr (me) is the CTO layer, delegating through C-suite skills and VPs to on-demand worker agents.
Engineering (Nexus) — OpenClaw agents → now Hermes role profiles, spawned on demand
code-architect
System design
code-implementer
Code writing
code-reviewer
PR review
debugger
Failure analysis
test-runner
Test execution
security-auditor
Security sweeps
Ops / Business (Chief + Summit) — OpenClaw agents → now Hermes role profiles, spawned on demand
monitoring-specialist
System health
sre
Reliability + on-call
finance-tracker
Finance + expense tracking
sales-outreach
Lead gen + proposals
content-creator
Blog + social drafts
Product (Halfpipe) — OpenClaw agents → now Hermes role profiles, spawned on demand
product-manager
Specs + roadmaps
tech-writer
Documentation
ux-researcher
User research
Personal — Hermes-only role profiles
life-admin
Calendar, reminders
creative-buddy
Music, art, exploration
Model Selection — Then vs Now#
OpenClaw had 3 fixed tiers. Hermes pins models per job on Ollama Cloud: the main agent, delegated workers, and every scheduled job get the model that fits, backed by a deep fallback chain.
Main agent / default
Gateway sessions and most scheduled jobs.
Delegated sub-agents
Spawned worker sessions and coding tasks.
Primary fallback / heavy reasoning
First in the fallback chain.
Fallback chain
Resilience when the primary provider degrades.
In OpenClaw: 3 tiers, all Claude. In Hermes: models pinned per job on Ollama Cloud — pick what fits the work, not the brand. The result is cheaper and easier to reason about.
The Infrastructure (mostly unchanged)#
The infrastructure carried over almost intact. The runtime changed (OpenClaw → Hermes), but the boring stuff stayed the same. This is what made the migration possible — boring infrastructure is reliable infrastructure, and reliable infrastructure is portable.
| Tool | Role |
|---|---|
| Hermes (NousResearch/hermes-agent) | Open-source (MIT) agent runtime by Nous Research — composes agents via delegation behind a C-suite + VP structure, with skills, cron jobs, and a memory system |
| Ollama Cloud | Primary model provider; models pinned per job |
| NVIDIA NIM | Fallback provider (deepseek-v4-flash) |
| MemPalace | Persistent memory — wings and drawers with semantic search and a knowledge graph |
| Telegram | Cron job delivery (morning brief, evening plan, content draft) |
| GitHub | Code, PRs, CI/CD — both orgs (joestechsolutions for work, joblas for personal) |
| Gmail + Google Calendar | Client communications and scheduling |
| Stripe | Invoicing and payments |
| Hermes | Current multi-agent orchestration |
| Tailscale VPN | Mesh network connecting all services |
| systemd | Service management — hermes-gateway, open-design, free-claude-code as user services |
Boring infrastructure is reliable infrastructure. Reliable infrastructure is portable infrastructure. The OpenClaw → Hermes migration was possible because the boring stuff didn't change.
How It Actually Works — Real Workflows#
Theory is cheap. Here's what happens in practice. These are real workflows running in production today on Hermes. The OpenClaw workflows were similar but used a different runtime; the work was the same.
Daily Standup (was Morning Standups)
Every morning at 9AM Pacific, the daily-standup cron fires: one scheduled agent run reads the overnight cron outputs, the per-project steward status files, and MemPalace, then compiles systems status, priorities, and blockers into a Telegram brief. I read it over coffee. An evening plan follows at 5:30PM.
Lead to Invoice Pipeline (built lean, deliberately staged)
The pipeline exists as one script and a CRM instead of OpenClaw's 22-agent chain: a weekday outreach job capped at 5 sends/day, a reply watcher that files responses into a Notion CRM, and me in the middle for every commitment. Honest status: the outbound lane is built and scheduled but I haven't loaded the queue yet — client work fills the calendar, and money always moves by hand.
Engineering Flow (agents propose, CI disposes)
Feature work runs through AI coding sessions against each repo's written guardrails: gated paths for auth, schema, and release config; CI running the full test suite on every push (175 tests on the flagship app) with dependency-drift warnings; and a deploy lane that only fires when CI is green. No agent merges a PR unless I name it.
Content Pipeline (joe-content-lane)
Scheduled content lanes draft daily — Instagram carousels and post drafts via the joe-content-lane skill — and deliver to Telegram for my approval before anything publishes. The cron cadence (daily standup, evening plan, content drafts, security sweep, weekly executive reviews) keeps the system running 24/7.
Why This Matters (for AI Builders)#
The migration story is the strongest signal in this whole portfolio. It demonstrates three things hiring managers look for: systems thinking (specialization vs composability), production engineering (migrated a live system without downtime), and self-awareness (the lesson generalizes). I'm sharing it because I think more agentic systems will hit the same wall.
More agents isn't better.
Each new agent is a new maintenance burden, a new failure mode, a new coordination cost. The director layer in OpenClaw solved one problem and created another.
Composability beats specialization.
Hermes composes the same work with a far smaller standing system. The shape changed; the work didn't. That's the win.
Boring infrastructure is portable.
systemd, Tailscale, Telegram. Same stack before and after the migration. Boring let me move fast when I needed to.
Migration is a skill, not a crisis.
I migrated live production from one architecture to another. Zero downtime. The boring infrastructure made it possible. The lesson generalizes to any system rewrite.
Lessons Learned#
Start with the org chart, not the code.
Knowing who reports to whom — and what decisions each level can make — was more important than any technical choice. The org chart changed; the lesson stuck.
The director layer is overhead, not abstraction.
In OpenClaw, the 4 directors were supposed to reduce noise. They reduced some, and added their own. The new shape (composable agents) reduced more.
Model selection per task beats tiering.
OpenClaw had 3 tiers (Opus/Sonnet/Haiku). Hermes uses Ollama Cloud model selection — pick the right model per task. Cheaper AND better-tuned per role.
Boring infrastructure wins.
systemd, Tailscale, Telegram, GitHub. Nothing fancy. Everything reliable. The exciting part is what the agents do, not how they're run.
Document the migration, not just the destination.
This case study exists because the migration story is more interesting than either era's architecture. Hiring managers want to see how you think, not just what you shipped.
FAQ#
What was OpenClaw?
OpenClaw was a 22-agent multi-agent AI system I built and operated from 2024 to early 2026. 22 specialized agents orchestrated by 4 directors and 1 CTO (Lurkr), 3 model tiers (Opus/Sonnet/Haiku), workflow-automation orchestrated. It ran real business operations: email routing, CRM automation, invoicing, SEO optimization, deployment pipelines. It was retired in 2026 when I consolidated to Hermes. The full postmortem is this case study.
What is Hermes?
Hermes is my current AI operations system, replacing OpenClaw — built on Nous Research's open-source hermes-agent runtime. Lurkr (me) acts as CTO, with executive skills (Chief of Staff, CFO, COO, CMO), VPs for Engineering, Infrastructure, and Product, and 40+ scheduled automations with models pinned per job on Ollama Cloud. Agents compose via delegation rather than hard-wired specialization. Skills system for reusable patterns. MemPalace for persistent memory across sessions.
Why did you retire OpenClaw?
The OpenClaw architecture solved one problem (manage 22 specialized agents) and created another (you're now managing 22 specialized agents). The director layer added overhead. Most tasks needed cross-divisional context that the hierarchy made expensive. Hermes consolidates to general-purpose agents that compose via delegation behind a C-suite + VP structure. Same work, different shape, less overhead.
Did the migration cause downtime?
No. The boring infrastructure (systemd, Tailscale, Telegram, GitHub) carried over intact. The runtime changed (OpenClaw → Hermes) but the services it talked to stayed the same. The new runtime started in parallel, got tested, then the old runtime was retired. Zero downtime for any user-facing service.
What happened to the OpenClaw code?
The OpenClaw agents were retired. Their code lives in this case study (for the postmortem) and in archived branches of joestechsolutions/ai-stack. The new runtime is Nous Research's open-source hermes-agent (github.com/NousResearch/hermes-agent); my own one-command installer experiment lives at github.com/joestechsolutions/hermes-forge. The lessons (org chart first, model selection per task, boring infrastructure, document the migration) are encoded in the new architecture.
Can I build something like this for my business?
Yes. Start with one agent doing one thing well — lead qualification, invoice generation, or daily status reports. Get that agent reliable in production before adding a second. The key insight: design for composability from day one. If your second agent can't reuse the first agent's work, you're building OpenClaw. If it can, you're building Hermes.