Everyone talks about AI agents. Few run them in production.
I've been running an AI agent 24/7 on my own server for 90+ days. Her name is Nyx. And for the first two months, I asked her to do everything: write posts, analyze funnels, audit landing pages, create email campaigns, and even optimize my daily task list.
The result: she did everything... poorly.
Not because the model was bad. But because a generalist agent loading 27KB of context to write an email is like hiring a CEO to also answer the phone.
The Problem: One Agent For Everything = Nothing Done Well
When a single agent handles growth, copywriting, UX, and operations, here's what happens:
- Constant context switching β In one session you ask it to analyze a funnel AND write 3 LinkedIn posts AND audit a landing page. Each switch burns tokens and dilutes quality.
- Generic output β It doesn't produce deep growth analysis OR compelling copy. Just "acceptable" everything.
- Sequential execution β Growth analysis β wait β copy β wait β UX audit β wait. Hours for something that could run in parallel.
I measured it: my main agent's growth task quality was 6/10. Copy: 5/10. UX: 4/10.
I wasn't leveraging AI. I was underutilizing it.
The Solution: 3 Specialized Sub-Agents
Instead of one generalist, I built three specialists that spawn on demand:
1. Growth Hacker π
What it does: Analyzes funnels, designs experiments with ICE scoring, identifies viral loops and acquisition channels.
Identity: It's not "an agent that knows about growth." It has its own decision framework: evaluates every opportunity with Impact Γ Confidence Γ Ease, knows my current metrics (270 members, $25 MRR, 75% engagement), and proposes concrete experiments with falsifiable hypotheses.
Real example: I asked it to analyze how to take my community from $25 to $5,000 MRR. In 8 minutes it generated:
- 5 strategy documents (growth strategy, experiments guide, tactical playbook, executive summary, quick-start checklist)
- 20 experiments prioritized by ICE score
- 7 viral loops with specific mechanics
- 90-day roadmap with metrics per phase
A growth consultant would've charged $2,000-5,000 for something similar. And taken 2-3 weeks.
2. Campaign Builder π’
What it does: Executes campaigns β takes the Growth Hacker's strategy and converts it into concrete assets: LinkedIn posts, email sequences, landing page copy, publishing calendars.
Identity: It knows my voice (direct, no BS, with humor), my platforms (Late API for scheduling, Listmonk for email, WordPress for blog), and each channel's rules (LinkedIn: always with image, never links in body, first comment for URLs).
Real example: It received the Growth Hacker's strategy and in 12 minutes generated:
- 3 LinkedIn posts optimized for 2026 algorithm (native video +69%, comments 15+ words = 2.5x weight)
- 5-email nurturing sequence (D+0 to D+10)
- Landing page copy proposal
- Weekly publishing calendar
3. UI Designer π¨
What it does: UX, accessibility, and performance audits. Reviews Lighthouse scores, WCAG compliance, and proposes concrete fixes with code.
Real example: I audited a landing page I'd created. The UI Designer found:
- Insufficient contrast (1.83:1 β fixed to WCAG compliant)
- Tap targets under 44px on mobile
- Missing
:focus-visiblestates for keyboard navigation - 507 Lighthouse errors from missing
robots.txt - Performance 81 β 97 after applying its fixes
The critical part: The UI Designer reviews BEFORE implementation. It publishes findings to a Telegram channel, I approve, and only then it gets implemented. Never the other way around.
How It Works in Practice
The magic isn't in individual agents. It's in the orchestration:
Me: "I need a lead magnet campaign for LinkedIn"
β
Nyx (main agent): Spawns Growth Hacker + Campaign Builder in parallel
β
Growth Hacker β analyzes funnel, metrics, proposes strategy
Campaign Builder β generates assets: posts, emails, landing copy
β
[Both finish in ~10 min, working simultaneously]
β
Nyx: Synthesizes both outputs β presents result to me
β
UI Designer: Audits proposed landing β publishes fixes
β
Me: Approve β Implementation happens
Total time: ~30 minutes (including my review).
Before: 8-10 hours doing everything sequentially with one agent.
Dedicated Channels Per Agent
Each sub-agent has its own Telegram channel. It's not cosmetic β it's functional:
- Topic 6012 β π Growth Hacker: I request analysis, it delivers strategy right there
- Topic 6013 β π’ Campaigns: Assets ready for approval
- Topic 6011 β π¨ UI/UX Design: Audits with screenshots and code
Bidirectional: I can request work AND receive results in the same place. Without polluting my main chat.
The Evolution: From "API Docs" to "Agent Identities"
The deepest change wasn't technical. It was conceptual.
Before, my "skills" were API documentation: "this is how you use Listmonk", "this is how you call Late API." Passive information.
Now they're agent identities with three components:
- Agent Identity β Who it is, what it knows, what it does NOT know (explicit boundaries)
- Workflow Integration β How it connects with other agents and tools
- Decision Framework β How it decides what to do (not just what it can do)
A Growth Hacker that only "knows about growth" is ChatGPT with a prompt. A Growth Hacker with ICE scoring, knowledge of my metrics, and an experimentation framework is a specialist.
The WordPress Plugins Born From This System
Two open-source tools emerged from this multi-agent architecture:
Lean CTAs β Dynamic CTAs by Category
The Growth Hacker identified that my blog had 15,000+ posts but zero CTAs pointing to my Skool community. All that traffic (107K users/month) wasn't converting.
The solution: a lightweight WordPress plugin that injects automatic CTAs based on post category:
- News posts β inline CTA at paragraph 3 inviting to the community
- Glossary β inline + final CTA
- Each category gets its own color and message
Zero JavaScript. Zero bloat. One indexed SQL query. The opposite of CTA plugins that weigh 500KB and slow your site down.
Lean Redirects β Redirects Without Drama
When I migrated my sites, I had hundreds of broken URLs. Existing redirect plugins are heavy, load unnecessary JavaScript, and sometimes break more than they fix.
Lean Redirects does exactly one thing: redirect. One table, one query, zero JavaScript. Currently being reviewed for WordPress.org.
"Lean" philosophy: If a plugin can't explain its reason to exist in one line, it's bloat.
The Numbers (Real, Not Inflated)
| Metric | Before (1 agent) | After (3 sub-agents) |
|---|---|---|
| Time for growth strategy | 8-10 hours | 30 minutes |
| Growth output quality | 6/10 | 8.5/10 |
| Copy output quality | 5/10 | 8/10 |
| UX audit quality | 4/10 (manual) | 9/10 (automated) |
| Cost per orchestration | ~$0.08 (1 Sonnet call) | ~$0.25 (3 agents) |
| Assets generated per session | 1-2 | 5-8 |
Cost went from $0.08 to $0.25 per session. But output went from 1-2 mediocre assets to 5-8 quality assets. The ROI is absurd.
Real monthly cost
- Growth Hacker: ~$3/month (15 analyses Γ $0.20)
- Campaign Builder: ~$4/month (20 executions Γ $0.20)
- UI Designer: ~$2/month (10 audits Γ $0.20)
- Total sub-agents: ~$9/month
Vs hiring freelancers:
- Growth consultant: $2,000-5,000/month
- Copywriter: $500-2,000/month
- UX auditor: $1,000-3,000/month
I'm not comparing quality (a senior human is still better at many things). But for 80% of operational tasks, $9/month vs $3,500/month changes the equation for a solopreneur.
Anti-Patterns: What NOT To Do
After weeks of iteration, these are the hard rules:
1. Never let a sub-agent execute externally
The sub-agent proposes, the human approves, the main agent executes.
If you let the Growth Hacker publish directly to LinkedIn or the Campaign Builder send emails without approval, you'll have problems. I learned this the hard way: a draft I didn't review got published with incorrect data.
2. One agent per domain, not per task
Wrong: Agent for creating posts, another for publishing, another for tracking.
Right: One Campaign Builder that handles the full campaign lifecycle.
If an agent's context exceeds 12KB, you probably need to split it. But don't fragment it into micro-agents that can't make complete decisions.
3. Focused context > big context
The Growth Hacker doesn't need my WordPress credentials. The UI Designer doesn't need my investment history. Each agent loads only what it needs (5-8KB vs 27KB from the main agent).
Result: cheaper models (Haiku) perform better with focused context than expensive models (Sonnet) with generic context.
How to Start (Without Overcomplicating)
You don't need 7 sub-agents on day one. I started with just one and scaled gradually.
Step 1: Identify your most repetitive task that requires expertise (not the easiest β the most frequent).
Step 2: Create an agent identity with 3 files: who it is, what tools it has, how it decides.
Step 3: Test it on 5 real tasks. Compare quality vs your main agent.
Step 4: If it works, add a dedicated channel and document the patterns.
The entire process is documented with ready-to-use configs and scripts in my OpenClaw Production Guide (open source, MIT).
What's Next
I'm working on:
- Orchestrator skill that coordinates sub-agents automatically based on request type
- Feedback loops where sub-agents learn from my corrections
- Cross-synthesis where the Growth Hacker critiques the Campaign Builder's output before showing it to me
The trend is clear: 2026 is the year agents stop being individual assistants and become teams. Big companies are already doing it (Salesforce, Google Cloud). The difference is that now a solopreneur with a $12/month VPS can have the same thing.
π Originally published in Spanish at cristiantala.com
Resources mentioned:
- π OpenClaw Production Guide β Complete guide with 13 case studies
- π Lean CTAs β WordPress plugin for dynamic CTAs
- π Lean Redirects β WordPress plugin for lean redirects
- π¦ OpenClaw β Open source gateway for AI agents
Top comments (0)