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, routed through Ollama Cloud model selection. The OpenClaw era is over. The lessons stuck.
14
Hermes Agents
Engineering, Infra, Product, Marketing, Personal
∞
Model Options
Ollama Cloud by task
5
Executive Functions
CTO + C-suite + 3 VPs
0
Downtime
Live migration
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 routed through Ollama Cloud model selection
In OpenClaw, Lurkr was a dedicated CTO agent. In Hermes, Lurkr (me) is the CTO layer, delegating through C-suite skills and VPs to the agents that do the work.
Engineering (Nexus) — Both eras
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) — Both eras
monitoring-specialist
System health
sre
Reliability + on-call
finance-tracker
Invoicing + Stripe
sales-outreach
Lead gen + proposals
content-creator
Blog + social drafts
Product (Halfpipe) — Both eras
product-manager
Specs + roadmaps
tech-writer
Documentation
ux-researcher
User research
Personal — Hermes-only
life-admin
Calendar, reminders
creative-buddy
Music, art, exploration
Model Selection — Then vs Now#
OpenClaw had 3 fixed tiers. Hermes uses Ollama Cloud model selection: the main agent and each sub-agent are routed to the model that fits the task. Specialization lost; fit won.
Main agent / default
General orchestration and high-stakes reasoning.
Architecture, strategy, security
Design decisions, root-cause analysis, security audits.
Code implementation
Writing production code against existing patterns.
Code review
Fast, code-specialized PR review.
Infrastructure / Platform
Ops decisions, deploy planning, capacity reasoning.
Monitoring + structured ops
System health, security sweeps, structured log analysis.
In OpenClaw: 3 tiers, all Claude. In Hermes: Ollama Cloud model selection — pick the model that fits the task, not the brand. The result is cheaper and better-tuned per role.
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 (hermes-forge) | Agent runtime — composes agents via delegation behind a C-suite + VP structure, with skills, cron jobs, and a memory system |
| Ollama Cloud | Primary model provider; main agent and sub-agents routed by task |
| NVIDIA NIM | Fallback provider (deepseek-v4-flash) |
| MemPalace | Persistent memory — 40,000+ drawers across wings, semantic search, 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.
Morning Briefs (was Morning Standups)
Every morning at 7:30AM Pacific, the morning_brief cron job fires. It composes via delegation: queries MemPalace for the last 24h of activity, asks the content-creator agent to draft a summary, and delivers it to Telegram. I read it over coffee.
Lead to Invoice Pipeline (was OpenClaw's signature workflow)
End-to-end: a lead comes in, gets qualified, turns into a proposal, gets reviewed by me, goes to the client, meeting gets scheduled, work gets done, invoice goes out. The pipeline runs on Hermes now via delegation — sales-outreach → content-creator → product-manager → finance-tracker. The same pipeline that took 22 agents in OpenClaw takes 5 in Hermes.
Engineering Flow (post-coding pipeline)
Feature requests flow from strategy through development to deployment. code-implementer writes code following the project's existing patterns. code-reviewer reviews for bugs and security. The post-coding hook runs security-auditor + test-runner automatically. The jts-pipeline-detect.sh hook auto-spawns the 8-stage JTS pipeline for client work.
Content Pipeline (joe-content-lane)
content-creator composes blog posts, case studies, social drafts from MemPalace context. tech-writer handles documentation. joe-content-lane skill provides the style guide. The cron cadence (morning brief, evening plan, content draft, security sweep, model bakeoff, weekly 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 6 fewer agents. 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 multi-agent AI system, replacing OpenClaw. Lurkr (me) acts as CTO, with executive skills (Chief of Staff, CFO, COO, CMO), VPs for Engineering, Infrastructure, and Product, and 14 named agents. Main agent and sub-agents are routed through Ollama Cloud model selection by task. Agents compose via delegation rather than hard-wired specialization. Skills system for reusable patterns. MemPalace for persistent memory across sessions. Open source at github.com/joestechsolutions/hermes-forge.
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, Stripe) 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 hermes-forge (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.