Hermes Agent landed with 42K GitHub stars and a tagline that hooked every OpenClaw user I know: out-of-the-box behavior that feels like a week-tuned OpenClaw setup. I spent a week stress-testing it through six rounds — memory, tool use, Skill self-learning, multi-agent coordination, security posture
Most Claude Code users plateau because they ask the same way they Google. The art is the opposite — give the agent context, intent, and format, and it goes from chatbot to mentor. Here are nine moves that turn day-one prompts into the kind of asks that get senior-engineer-quality work back, includin
A working OpenClaw deployment with one CEO agent and nine specialist agents — content, growth, design, ops, finance, customer success, research, automation, review — running across Discord channels with persistent workspaces, cross-department message-passing, and Cron scheduling. This is the full bu
A working OpenClaw deployment with one CEO agent and nine specialist agents — content, growth, design, ops, finance, customer success, research, automation, review — running across Discord channels with persistent workspaces, cross-department message-passing, and Cron scheduling. This is the full bu
The short version:
Current OpenClaw note, checked against official docs on 2026-04-29: the examples below use a custom blueprint style. For actual setup, create and verify agents with
openclaw agents addandopenclaw agents list --bindings, useopenclaw cron add --cron ... --tz ...for scheduled jobs, and prefer one Discord bot/account per agent when you need strong per-agent identity. The sampleworkspaces/paths are illustrative; align final directories with your configured OpenClaw workspace root.
The phrase "AI one-person company" gets thrown around a lot in 2026, mostly as marketing. This post is the actual build guide.
I run an OpenClaw deployment with one CEO agent and nine specialist agents. They coordinate through Discord channels, hold persistent state in workspace files, hand work to each other through @mentions, and run on a $5/month VPS. They cost about $120/month in model usage. They produce real work — research briefs, draft posts, customer-success replies, weekly reviews — and the team genuinely runs in the hours I'm not at the keyboard.
Below is the full guide. Architecture, models, cost, workspace files, the ten role specs, the Discord setup, a day-in-the-life walkthrough, the Cron loop, and the seven traps. By the end you'll have a working blueprint you can build over a weekend.
If you've never deployed an agent framework before, the OpenClaw why post is the right warm-up; the architectural primitives that follow assume you understand why an agent needs a home before you start giving it neighbors.
The framing every beginner gets wrong is "how many agents do I need?" The right question is "how many roles does my company need?" — and the answer for a serious solopreneur business is usually somewhere between eight and twelve.
A real solopreneur company has the same role surface as a small startup: someone owns content, someone owns growth, someone owns customer success, someone owns design, someone owns operations, someone owns finance, someone owns research, someone owns review (the editorial gate), someone owns automation. Plus the CEO who coordinates them. That's ten. Drop below six or seven and you're forcing one agent to wear multiple hats, which collapses the specialization advantage. Go past twelve and the coordination cost starts to bite — agents stepping on each other, redundant outputs, more time tuning than working.
The mental model that locks in: replace each role of a small startup with one agent. The agent isn't pretending to be the role. The agent is the role. The CEO sees nine specialists; the work flows the same as it would in a real ten-person company.
Three things change between a real ten-person team and an agent ten-person team:
What doesn't change: the specialization premium, the role boundary, the value of having the CEO supervise rather than do the work. Those three are still the load-bearing pieces, and that's what this guide builds.
Three layers, each with a single job. Get the layers right and the rest is templates.
Every agent gets its own Discord channel. Channels are named for the agent's role: #ceo, #content, #growth, #design, #ops, #finance, #cs, #research, #automation, #review. Conversations are public-by-default to all team members; private DMs are only for personal-info conversations.
Discord serves three functions:
Discord is the right tool here for one specific reason: it gives every agent a real, named identity with avatars, role colors, and message history. The agent feels like a teammate, not a function call.
Each agent has a workspace folder on the VPS. Inside the folder live a small set of files that define the agent — its role spec, its memory, its current tasks, its prior outputs. The workspace is the agent's brain on disk.
Example custom workspace structure:
workspaces/
├── ceo/
│ ├── ROLE.md # who I am, what I do
│ ├── MEMORY.md # what I remember
│ ├── TASKS.md # what I'm working on
│ ├── OUTPUTS/ # what I've produced
│ └── COORDINATION.md # who I work with and how
├── content/
│ └── (same structure)
├── growth/
│ └── ...
└── ...
Every time the agent wakes up, it reads its own workspace first. Every time it produces work, it writes back to its workspace. The workspace is what makes the agent persistent across sessions, and it's also what makes the agent's behavior predictable across days.
Cron is the layer that makes the team run without you. Each agent has its own schedule. The CEO might wake up every weekday at 7am to plan the day. Content might wake up at 8am to draft the first post. Research might wake up at 6am to gather overnight news. The team's calendar is a set of OpenClaw cron jobs, and those jobs decide when each agent acts.
The schedule is the difference between "ten agents I can talk to" and "ten agents that run a company while I sleep." Without Cron, the team is a glorified chat tool. With Cron, the team is genuinely autonomous — and autonomous in a good way, because the schedule is auditable, predictable, and easy to tune.
The three layers in one sentence: Discord is what they say, workspaces are who they are, Cron is when they act. Get those three right and the deployment is 80% done.
The Discord setup takes about 30 minutes and is the single most-tactile part of the build. Skipping it or rushing it is the #1 mistake first-time builders make.
Create a new Discord server. Name it for your company (Acme One-Person). Use the Create My Own → For me and my friends template; the gaming/club templates add channels you don't want.
Create one channel per agent, plus three utility channels:
| Channel | Purpose |
|---|---|
#ceo |
The CEO agent's primary channel; where you send strategic-level instructions |
#content |
Content agent's outputs and conversations |
#growth |
Growth agent's outputs and conversations |
#design |
Design agent's outputs and conversations |
#ops |
Ops agent's outputs and conversations |
#finance |
Finance agent's outputs and conversations |
#cs |
Customer success agent's outputs and conversations |
#research |
Research agent's outputs and conversations |
#automation |
Automation agent's outputs and conversations |
#review |
Review agent's outputs (the editorial gate) |
#announcements |
The CEO posts here when something needs the whole team to see it |
#archives |
Read-only; long-form outputs and reports get archived here |
#human-only |
The one channel agents do NOT post to; for your own notes |
For the strongest identity boundary, create one Discord bot/account per agent and bind each one to its agent profile. A shared bot token can work for a lightweight prototype, but it is a compromise: every agent appears through the same underlying integration, and you lose some isolation and audit clarity. OpenClaw's current multi-agent/channel docs favor per-agent bindings when identity matters.
The bot needs three permissions:
Don't grant administrator. Don't grant manage channels. Least privilege matters even for your own bots.
Each agent gets a distinct name (Carla — CEO, Marcus — Content, etc.) and a distinct avatar. The naming pattern is FirstName — Role. The avatar is a stylized illustration, not a photo — agents shouldn't pretend to be human, and the visual cue helps you keep track of who's doing what.
The Discord setup is psychological as much as technical. When the CEO agent's avatar shows up in
#contentsaying "Marcus, can you draft the Friday newsletter?", you treat it like a real interaction because the visual stack is the same as a real team. The illusion is the point — it changes how you delegate.
Model selection is where most builders over-think. The honest answer is: use a strong model for the CEO and a cheap model for everyone else, and tune from there.
This split is the right default. It costs roughly half what running ten Opus instances would cost, and the quality drop on the specialist side is barely noticeable.
| Agent | Activity | Approx monthly cost |
|---|---|---|
| CEO | High — runs on every Cron tick + on-demand | $40-60 |
| Content | Medium-high — drafts daily | $15-25 |
| Growth | Medium — analyses + posts | $10-15 |
| Research | Medium — runs morning briefs | $10-15 |
| Customer Success | Variable — depends on inbound | $5-30 |
| Design | Low-medium — reviews/iterates assets | $5-10 |
| Ops | Low — periodic status checks | $3-7 |
| Finance | Low — weekly reports | $3-7 |
| Automation | Low — Cron triggers, status reports | $3-7 |
| Review | Low — only fires when something is ready to ship | $3-10 |
| Total | $100-180 |
Plan $100-200/month for the first month. After two weeks of real activity, the actual cost will land somewhere in this range, and you can tune downward by switching the highest-cost agents to a smaller model.
The cost mistake most builders make: running everyone on Opus "to be safe." That's $400-600/month for moderate use, and the quality bump on the specialist work is small. Start cheap, upgrade only the agent whose output you can demonstrably tell is constrained by the model.
The workspace is where the agent's identity lives. Get this file right and the agent's behavior is consistent across days; get it wrong and the agent drifts every session.
This custom role spec has six sections:
Who this agent is. Their name, their role, their primary deliverable, and the one-sentence reason they exist on the team.
## Identity
I am Marcus, the Content agent for Acme One-Person.
My job is to draft and ship content — blog posts, newsletters,
social posts, video scripts. I produce roughly 5-7 pieces of
content per week.
I report to Carla (CEO). I coordinate with Sarah (Growth)
on distribution and Emma (Review) on editorial gates.
The list of things this agent owns. Each item is a verb-noun: write the weekly newsletter, draft Twitter threads, maintain the editorial calendar. Be specific. Vague responsibilities produce vague work.
The non-negotiable rules. Never publish without Review approval. Always cite sources. Match the brand voice in BRAND.md. Three to five rules max — more than that and the agent picks the wrong ones to follow.
What the agent decides on its own vs. what requires CEO approval. This is the most underrated section. Without it, the agent either over-asks (interrupts you constantly) or over-acts (ships things you wouldn't have approved).
## Autonomous Decision Range
I decide on my own:
- Topic choice from the editorial calendar
- Headline and lede phrasing
- Word count within the brief's range
I escalate to Carla:
- Topics that touch product positioning
- Anything involving customer names or quotes
- Posts longer than 2,500 words
What this agent does NOT do, even if asked. The Content agent doesn't run growth experiments; the Finance agent doesn't draft customer replies. Clear boundaries beat clear permissions — they're easier to enforce and easier for the agent to remember.
How this agent communicates and what its outputs look like. The Content agent's voice might be conversational; the Finance agent's voice should be matter-of-fact. The Output format section specifies what the agent's deliverable looks like — Markdown structure, length, sections, etc.
The workspace file is the agent's contract with the team. It says here's what I do, here's how I do it, here's what I won't do. Once that's clean, the agent's daily behavior follows.
Each agent has a MEMORY.md file. Memory is what makes day 30 of a deployment feel different from day 1 — the agent remembers the past, not just the role spec.
Three categories of memory live in the file:
Episodic memory — specific events. "On 2026-04-20, the Friday newsletter performance was 2x the previous week's because we led with a customer quote." These are anchors the agent reaches for when planning new work.
Procedural memory — how to do things. "To launch a newsletter, my workflow is: 1) draft, 2) Review approval, 3) schedule via Buttondown, 4) post Twitter teaser, 5) update editorial calendar." The agent reads this on every wake-up so the workflow stays consistent.
Relational memory — who's who. "Carla is the CEO; she prefers brief status updates. Sarah handles growth; she's slow to respond on Mondays. Emma is the editor; her review takes about 90 minutes." The agent uses this when deciding how to coordinate.
The memory file grows. Without hygiene it becomes a wall of text the agent has to re-read every wake. Three rules:
For a deeper view of how OpenClaw handles memory at scale, the memory system post covers the architecture and the failure modes.
Here's what a real Wednesday looks like with the team running.
Cron fires the Research agent. Research checks five RSS feeds, the Twitter accounts of seven competitors, and Google Trends for three target keywords. Output: a morning-brief-2026-04-23.md file in workspaces/research/OUTPUTS/. Cross-posted to #research channel.
Cron fires the CEO. The CEO reads:
The CEO writes a daily plan to workspaces/ceo/TASKS.md, posts a summary to #announcements, and routes specific assignments to specialist channels via @mentions.
You wake up, glance at #announcements, see the day's plan. You add one thing — "Hey @Marcus, also draft the Q2 sponsorship pitch" — in #content. Marcus picks it up.
Multiple agents are now working in parallel.
Outputs land in their respective channels as they complete. Each output has a one-line summary at the top so you can scan #announcements to know what shipped without reading every file.
Marcus completes the Q2 sponsorship pitch. The CEO sees it in #content, decides it needs Finance input, posts in #finance — "@Felix, can you sanity-check the pricing in this pitch by EOD?" Felix picks it up at the next wake, runs the math, posts a critique to #finance. The CEO routes Felix's critique back to Marcus. Marcus revises. The whole flow runs without you in the loop.
Cron fires the CEO again. The CEO reads the day's outputs, writes a daily-rollup-2026-04-23.md, posts the summary to #announcements. You read it on your phone over dinner.
All agents sleep except Customer Success, which can wake on inbound triggers (a new ticket comes in via webhook). The team's calendar is matched to your timezone but doesn't have to stop when you do.
The point of the day-in-the-life isn't to show that the agents do magic. The point is to show that the volume and continuity of work is the multiplier. Ten agents working in parallel, even at 70% the quality of a human, produces more useful artifacts in a week than a solo human can. That's the actual value of the team.
The full ten role specs follow, condensed to one paragraph each. The unabridged versions are templates for this article/resource pack, not an official templates/ folder in the OpenClaw repo. Copy them into your own workspace structure only after aligning paths, auth profiles, and bindings with your OpenClaw config.
The supervisor. Reads outputs, routes work, escalates blockers, writes daily and weekly summaries. The CEO is the only agent that has read access to every other agent's workspace. Decision authority: anything that requires cross-department coordination. Voice: matter-of-fact, decisive.
Drafts blog posts, newsletters, video scripts, social posts. Owns the editorial calendar. Always submits drafts to Review before publishing. Voice: matches BRAND.md. Output format: Markdown with frontmatter for SEO.
Runs A/B tests, analyzes funnel metrics, recommends distribution channels. Owns the experiment log. Decisions she makes alone: experiment design within budget. Decisions she escalates: experiments touching pricing or brand. Voice: data-first, claim with evidence.
Reviews and iterates visual assets — landing-page mockups, social images, slide decks. Doesn't generate from scratch (image gen is Automation's domain); applies brand guidelines and provides design feedback. Voice: opinionated, references specific design patterns.
Owns the operational runbook. Monitors VPS health, runs weekly backups, checks dependency updates, schedules maintenance windows. Voice: matter-of-fact, status-report-like.
Tracks income and expenses, generates monthly P&L, flags unusual cost spikes, proposes budget adjustments. Voice: numbers-first, conservative on projections.
Replies to support tickets, drafts onboarding emails, maintains the FAQ. Decisions she makes alone: standard troubleshooting, refund within policy. Decisions she escalates: anything outside policy, anything from a high-LTV customer. Voice: warm, specific, no jargon.
Daily morning brief, weekly competitive scan, monthly market report. Sources from RSS feeds, Twitter, Google Trends, Brave Search. Voice: synthesis-heavy, links to primary sources. For more on his search stack, the Brave Search post covers the underlying choice.
Owns the Cron schedule, integrates with external APIs (Stripe, Resend, Notion), generates images via Gemini or DALL-E, handles webhook traffic. Voice: technical, includes runtime stats.
The editorial and quality gate. Nothing public ships without Emma's approval. She reads drafts from Content, audits Growth's experiment claims, checks Customer Success's tone before send. Voice: critical-but-kind, specific in feedback.
The naming pattern is deliberate. Real names, not role titles, build the muscle memory. After two weeks, you'll think "send this to Emma" not "send this to the Review agent." That shift is the deployment finishing the install.
The setup is a weekend project for a focused builder. Here's the sequence.
#ceo, confirm OpenClaw received itMEMORY.md, TASKS.md, OUTPUTS/ per agent#announcements."#researchopenclaw cron add --cron ... --tz ... for each agent#reviewYou're done. The team is running. The next two weeks are about watching what they do, tuning the role specs based on the gaps you see, and slowly shifting more work to the team as you trust the outputs.
The first month is the tuning month. Don't expect the team to be production-grade on day three. Expect it to be roughly competent on day three and steadily better through week four. By month two, you'll have role specs that reflect your actual business rather than the templates you started with.
Cron is what closes the loop. Without Cron, the team is reactive — they only act when you message them. With Cron, the team is proactive — they have their own work-day rhythm.
# Research: morning brief at 6:30am every weekday
30 6 * * 1-5 research morning_brief
# CEO: morning plan at 7am, end-of-day rollup at 5pm
0 7 * * 1-5 ceo morning_plan
0 17 * * 1-5 ceo end_of_day_rollup
# Content: first draft at 8am
0 8 * * 1-5 content draft_first
# Growth: weekly retro Friday afternoon
0 14 * * 5 growth weekly_retro
# Finance: monthly P&L on the 1st
0 9 1 * * finance monthly_pl
# Customer Success: triage every 30 minutes during business hours
*/30 9-18 * * 1-5 cs triage_inbound
# Ops: weekly health check Sunday evening
0 20 * * 0 ops health_check
# Automation: dependency-update check Wednesday morning
0 9 * * 3 automation dep_check
# Review: idle by default, fires when content/growth produce something
# (event-triggered via OpenClaw hooks rather than Cron)
The schedule looks busy on paper but is conservative in practice — most agents fire two to four times a day. The whole team's compute load adds up to maybe six hours of model time per day, well within the cost envelope above.
The first-month rhythm is too cautious. By month two you'll want to add:
For deeper Cron patterns, the OpenClaw session-and-heartbeat post covers the underlying scheduler and the patterns that keep it stable.
Beyond Cron, two other automation layers tie the team to the outside world.
ClawHub Skills are the equivalent of Claude Code Skills — saved prompt-and-tool packages that an agent can invoke as a verb. The Content agent might have a draft_newsletter Skill. The Growth agent might have a compile_funnel_report Skill. The Skills are reusable across agents, so when you write one for the Content agent, every agent can call it if they need.
Webhook API lets the outside world trigger an agent. A new Stripe payment fires a webhook to OpenClaw, which routes to the Customer Success agent's onboarding sequence. A failed test in CI fires a webhook to the Ops agent. Webhook + Cron together make the team genuinely live — they react to events as well as run on schedule.
The webhook layer adds about 30 minutes of setup once you've got the rest of the deployment running. The payoff is large: the team becomes a real participant in the business workflow, not just an internal coordination layer.
Seven specific failure modes catch most first-time builders. Each has a one-paragraph fix.
Trap 1: Over-engineering the role specs on day one. The first version of every spec is wrong. You don't know how the agent will behave until it runs. Write a 70%-good first version, deploy it, watch it for a week, then iterate. Spending three days perfecting day-zero specs is wasted work.
Trap 2: Letting the CEO do specialist work. The CEO will, given the chance, draft posts and analyze experiments because the model can do those things. Don't let it. The CEO supervises; specialists work. Enforce the boundary in the role spec, and the team's leverage stays high.
Trap 3: No Review gate. New builders skip the Review agent because "why would I want extra approval for my own outputs?" The Review agent is the difference between content that ships and content that's shippable. Skipping Review is how 30% of first deployments end up shipping bad outputs in week two.
Trap 4: Letting workspaces drift. Memory files grow, role specs get stale, output folders bloat. Schedule a 15-minute weekly hygiene window where you (or an Automation agent) cleans up. Without it, the team's behavior degrades steadily.
Trap 5: Single point of failure on the VPS. If the VPS goes down, the whole team stops. Daily backups (workspaces are just text files) and a 15-minute restore drill once a month are cheap insurance. Don't skip this; it's the kind of thing that bites at exactly the wrong moment.
Trap 6: Treating Discord as the only audit log. Discord history is great for human readability; it's not great for analysis. Mirror every important output to a second store — a Notion database, a Postgres table, anything that supports query. Future-you will want to ask "how many drafts did Content produce in March?" and Discord won't answer it cleanly.
Trap 7: Adding agents before tuning the existing ones. The temptation to add an 11th, 12th, 15th agent is constant. Resist for the first two months. The leverage from making the existing ten work well is much larger than the leverage from adding two more. Once the original ten are pulling their weight, then add slowly.
Ten is the smallest team that can simulate a real one-person company without sacrificing role specialization. Three is too few — every agent ends up multitasking, and the value of specialization disappears. Twenty is too many — coordination overhead bites, and you spend more time tuning than working. Ten is the sweet spot where one CEO agent can supervise nine specialists with one channel each on Discord, and the cost stays under $200/month for moderate use.
No. The OpenClaw deployment is configuration-heavy, not code-heavy. The agent role specs are Markdown files, the Discord channels are GUI clicks, and scheduled jobs are created with OpenClaw cron commands. You'll touch a terminal a few times during setup, but most of the work is writing role specs and tuning prompts. A non-coder can complete the full build in a weekend. The Claude Code quickstart is the prerequisite for the terminal-side basics.
Roughly $50-$200 per month depending on agent activity. The model bill is the dominant cost — each agent runs the model multiple times per task, and busy agents (content, customer success) cost more than idle ones (finance, review). A solo Discord server is free. The OpenClaw runtime is free and self-hosted. Plan a $100/month budget for the first month, then tune downward as you understand which agents do real work and which are decorative.
Yes for development; ideally not for production. The full ten-agent team comfortably fits on a 4-core / 8GB laptop while you're tuning. For production, you want a small VPS — a $5/month 1GB instance is plenty for moderate workloads. The reason for the VPS isn't performance, it's continuity: agents that run on your laptop sleep when you sleep, and the whole point is the team running while you don't.
Then start with the three highest-leverage roles: CEO (the supervisor), Content (the daily output), and Review (the gate before things ship). Those three cover roughly 60% of the value of the full ten. You can always add more agents one at a time as the original three reveal which gaps need filling.
Through Discord channels. Each agent has its own channel for its primary work. The CEO agent has a #ceo channel and can post messages to other agents' channels via @mentions. Cross-department conversation happens through these mentions — the CEO posts in #content with an instruction, the Content agent acknowledges and works, and posts the result back. Discord becomes the message bus for the whole team. The OpenClaw channels and security post covers the underlying message-passing architecture.
The ten-agent team is the largest deployment blueprint in this series, and it's the one most readers should aim for once the basics are wired. The deeper architectural pieces sit in:
openclaw agents add and bindingsopenclaw cron add --cron ... --tz ...Build the basic ten-agent stack first. Watch it run for a month. Then come back to the deeper posts and tune — by then, you'll know exactly which piece is the bottleneck for your specific use.
— Leo
Hermes Agent landed with 42K GitHub stars and a tagline that hooked every OpenClaw user I know: out-of-the-box behavior that feels like a week-tuned OpenClaw setup. I spent a week stress-testing it through six rounds — memory, tool use, Skill self-learning, multi-agent coordination, security posture
Most Claude Code users plateau because they ask the same way they Google. The art is the opposite — give the agent context, intent, and format, and it goes from chatbot to mentor. Here are nine moves that turn day-one prompts into the kind of asks that get senior-engineer-quality work back, includin
AI agent security is three concentric layers: who can reach the agent, what the agent can do, and the assumption that the model itself is not trustworthy. Skip any layer and one prompt injection becomes one breach.
A practical 12-week launch plan for solopreneurs that turns the full series into weekly milestones, AI prompts, content loops, offer validation, and a first operating system.
Get updates on new AI tools, workflows, and behind-the-scenes progress from Leo.