How I Set Up OpenClaw: A 3-Month Journey with My AI Swarm

Three months ago, I didn't have a personal AI assistant. Today, I have a swarm of 3 agents that research, write, and review while I sleep. Here's exactly how I built it.

The Wake-Up Call

It started with a simple realization: I was spending 6+ hours every Sunday researching and writing my newsletter. The work was valuable, but the process was painfully manual.

I'd heard about OpenClaw — an open-source personal AI assistant that could actually do things, not just chat. But I'd also heard it was complex to set up. It took me three attempts over two weeks to get it running properly.

Month 1: The Setup Struggle

My first attempt failed because I tried to run it on my main MacBook Pro. Don't do this. OpenClaw needs to run 24/7, and your daily driver laptop will sleep, restart, and interrupt the process.

My second attempt failed because I used the wrong Python version. OpenClaw requires Python 3.10+, and I had 3.9 running. The error messages were cryptic, and I spent a full day troubleshooting before realizing the version mismatch.

My third attempt succeeded. Here's what worked:

The Winning Setup

1. Dedicated Hardware: I repurposed a Mac Mini M2 (8GB RAM) that was sitting in a drawer. It's now my "AI coworker" machine, running headless in my office.
2. Clean Environment: Fresh macOS install, dedicated user account, no other software running.
3. Python 3.11: Installed via pyenv, completely isolated from system Python.
4. Telegram Bot: Created via BotFather, saved the API token securely in 1Password.

The installation itself took 30 minutes once I had the right environment. The real time investment was understanding the architecture:

OpenClaw Architecture:
├── Core Engine (message parsing, task routing)
├── Agent Registry (defines available agents)
├── Tool Suite (filesystem, web, code execution)
└── LLM Interface (connects to AI models)

My Setup:
├── Hardware: Mac Mini M2 (8GB)
├── Connection: Telegram
├── LLM: Kimi K2.5 (primary) + Claude (fallback)
└── Runtime: 24/7 via launchd

Month 2: Building the Swarm

Once OpenClaw was running, I started building my agent team. I began with one agent, then gradually added more as I understood the coordination patterns.

Agent 1: Scout (Research)

Scout was my first agent. His job: find and summarize information from 50+ sources every Friday.

I defined his role in the agent registry:

Name: Scout
Role: Research Agent
Responsibilities:
  - Monitor AI news sources
  - Track emerging tools and frameworks
  - Summarize findings into digestible reports
  - Flag high-priority developments

Tools:
  - web_search (Brave API)
  - web_fetch (content extraction)
  - file_write (save summaries)
  
Schedule: Every Friday, 6 AM

The breakthrough came when I realized Scout could proactively alert me. Instead of me asking "what's new in AI?" Scout would message me: "Found 3 major developments this week. Here's my analysis..."

Agent 2: Quill (Writing)

Quill joined in week 4. His job: take Scout's research and draft newsletter sections.

I was skeptical at first. Could an AI actually write in my voice? The answer: not perfectly, but close enough to be useful. Quill generates first drafts that capture the structure and key points. I then edit for tone and add my personal takes.

The time savings: 4 hours per newsletter.

Agent 3: Peter (Review)

Peter was the final addition. His job: fact-check, catch errors, and suggest improvements before publication.

Peter caught three factual errors in his first week—errors I would have missed because I was too close to the material. He also suggests structural improvements: "This section would work better if moved earlier" or "Consider adding a counter-argument here."

Month 3: The Workflow Clicked

By month 3, the coordination between agents felt natural. Here's my actual Sunday morning routine now:

Friday 6 PM: Scout completes research, saves to shared folder
Saturday 10 AM: Quill drafts 3 newsletter sections
Saturday 8 PM: Peter reviews, flags 2 issues, suggests improvements
Sunday 7 AM: I wake up, review the compiled draft
Sunday 9 AM: I edit for tone, add personal commentary
Sunday 11 AM: Newsletter published

Total active work time: 2.5 hours. Previously: 6+ hours.

But the real value isn't just time savings. It's quality. Scout finds sources I'd miss. Quill structures arguments I wouldn't consider. Peter catches errors I'd overlook. The output is better than what I could produce alone.

The Technical Setup: Exact Steps

For those who want to replicate this, here's my exact setup:

Step 1: Hardware

• Mac Mini M2 (8GB RAM, 256GB SSD)
• Dedicated power outlet + Ethernet
• No monitor, keyboard, or mouse (headless setup)
• Remote access via Screen Sharing

Step 2: Software Environment

# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Python 3.11
brew install pyenv
pyenv install 3.11.6
pyenv global 3.11.6

# Install OpenClaw
pip install openclaw

# Verify installation
openclaw --version

Step 3: Telegram Bot

1. Message @BotFather on Telegram
2. Create new bot: /newbot
3. Name it (e.g., "Caiado AI Assistant")
4. Save the API token securely
5. Start a chat with your bot

Step 4: OpenClaw Configuration

# Create config directory
mkdir -p ~/.openclaw

# Create config file
cat > ~/.openclaw/config.yaml << EOF
telegram:
  api_token: "YOUR_TELEGRAM_BOT_TOKEN"
  allowed_users:
    - YOUR_TELEGRAM_USER_ID

agents:
  scout:
    name: "Scout"
    role: "research_agent"
    model: "kimi-k2.5"
    
  quill:
    name: "Quill"
    role: "writing_agent"
    model: "claude-sonnet-4.6"
    
  peter:
    name: "Peter"
    role: "review_agent"
    model: "claude-opus-4.6"

tools:
  - web_search
  - web_fetch
  - file_read
  - file_write
  - code_execute
EOF

# Start OpenClaw
openclaw start

Step 5: Launch Agent

To keep OpenClaw running 24/7, I use launchd:

# Create launchd plist
cat > ~/Library/LaunchAgents/com.openclaw.plist << EOF




    Label
    com.openclaw
    ProgramArguments
    
        /usr/local/bin/openclaw
        start
    
    RunAtLoad
    
    KeepAlive
    
    StandardOutPath
    /var/log/openclaw.log
    StandardErrorPath
    /var/log/openclaw.error.log


EOF

# Load the service
launchctl load ~/Library/LaunchAgents/com.openclaw.plist

# Verify it's running
launchctl list | grep openclaw

The Reality Check

Three months in, here's what I wish I'd known from day one:

1. Start smaller. I tried to build 5 agents immediately. It was chaos. Start with one agent, one task, one day a week. Scale gradually.

2. The first week is frustrating. Agents make mistakes. They hallucinate. They misunderstand instructions. This is normal. By week 3, they start understanding your patterns.

3. Prompts matter more than models. I spent too much time comparing Kimi vs Claude vs GPT. The real difference is how well you define the agent's role, responsibilities, and constraints.

4. Human-in-the-loop is essential. I never let agents publish directly. They draft, I review, I approve. This isn't about distrust—it's about maintaining quality and voice.

5. Costs add up faster than expected. I budgeted $50/month. Actual cost: $180/month. Track your token usage obsessively. I use a simple spreadsheet updated daily.

What's Next

I'm now expanding beyond the newsletter workflow. My agents are helping with:

• Code review for the kAIbot Robot Project
• Social media content scheduling
• Research for podcast episodes
• Drafting investor updates

The goal isn't to replace myself. It's to amplify what I can do while focusing on the work that only I can do: strategy, vision, and human connection.

Questions?

I'm documenting this journey in real-time. Follow along on X/Twitter at @scaiado or subscribe to the Obsolete by AI newsletter for weekly updates.

The future of work isn't humans vs. AI. It's humans with AI. And that future is already here—you just have to set it up.