**Build Your AI Command Center from Zero in One Afternoon** By Garfield Lawrence, Founder of OpenClaw Skill Packs --- You are about to build something most people think requires a team of engineers and six months of development. By the end of this guide, you will have a **fully operational AI command center** running on your own machine. Not a toy. Not a demo. A real system with agents that research, write, build, and execute tasks — on autopilot, 24 hours a day, 7 days a week.
Matching deployment kit
This scorecard is free to inspect. The matching kit gives you the setup order, templates, example outputs, test checklist, and launch path for using this kind of skill in a real workflow.
Scanned with AI Fleet Shield · Apr 1, 2026
Total
20
Passed
20
Warned
0
Failed
0
No critical findings detected in scan.
No warnings surfaced in scan.
No positive signals detected. Review findings before running.
Plain-English breakdown
Build Your AI Command Center from Zero in One Afternoon
By Garfield Lawrence, Founder of OpenClaw Skill Packs
You are about to build something most people think requires a team of engineers and six months of development.
By the end of this guide, you will have a fully operational AI command center running on your own machine. Not a toy. Not a demo. A real system with agents that research, write, build, and execute tasks — on autopilot, 24 hours a day, 7 days a week.
Here is what you will have when you finish:
No coding experience needed. If you can open a terminal and paste commands, you can do this.
The system you are building is the same architecture behind HIVE OS — the multi-agent operating system that runs three real businesses and six SaaS products simultaneously. We stripped it down to the essentials so you can deploy it in one afternoon.
One afternoon. $29. Your own AI workforce.
Let's build it.
You need five things. Most of them are free.
Do not install these yet. The step-by-step section walks you through each one in order.
| Tool | What It Does | Cost | |------|-------------|------| | Homebrew | Package manager (installs everything else) | Free | | Node.js 20+ | Runs the OpenClaw gateway | Free | | Python 3.12+ | Runs agent workers and scripts | Free | | Git | Clones repositories | Free | | Ollama | Local AI model inference | Free |
| Provider | What You Get | Cost | |----------|-------------|------| | Anthropic (Claude) | Best reasoning, best for complex tasks | ~$3/M input, ~$15/M output tokens | | OpenAI (GPT-4o) | Strong alternative, wide compatibility | ~$2.50/M input, ~$10/M output tokens |
Get your key now. You will need it during setup.
Pro tip: Start with Anthropic. Claude is purpose-built for agent work — tool use, long context, structured output. It is what we run in production.
If you have never used a terminal before, here is all you need to know: you type a command, press Enter, and the computer executes it. That is it. Every command in this guide is copy-paste ready.
Before you build, you need to understand what you are building. This takes three minutes to read and will save you hours of confusion later.
┌─────────────────────────────────────────────────┐
│ YOUR MACHINE │
│ │
│ ┌──────────┐ ┌───────────────────────────┐ │
│ │ YOU │───▶│ OPENCLAW GATEWAY │ │
│ │ (terminal)│ │ (routes tasks to agents) │ │
│ └──────────┘ └─────────┬─────────────────┘ │
│ │ │
│ ┌─────────────┼─────────────┐ │
│ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ AGENT 1 │ │ AGENT 2 │ │ AGENT 3 │ │
│ │ Research │ │ Writer │ │ Builder │ │
│ │ │ │ │ │ │ │
│ │ SOUL.md │ │ SOUL.md │ │ SOUL.md │ │
│ │IDENTITY │ │IDENTITY │ │IDENTITY │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ TASK QUEUE │ │
│ │ (Supabase or local SQLite) │ │
│ └─────────────────────────────────────┘ │
│ │
│ ┌──────────────┐ ┌────────────────────────┐ │
│ │ OLLAMA │ │ PAPERCLIP │ │
│ │ (local LLMs) │ │ (agent orchestration) │ │
│ └──────────────┘ └────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ MEMORY / PERSISTENCE │ │
│ │ (Qdrant vector DB + Supabase) │ │
│ └──────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘
The Gateway is the front door. Every request goes through it. It decides which agent handles the task, manages rate limits, and tracks what is happening. Think of it as the dispatcher in a taxi company.
Agents are specialized workers. Each one has a defined role, personality, and set of capabilities. A research agent searches the web. A writer agent creates content. A builder agent writes code. They do not overlap. They do not fight. Each one does its job.
SOUL.md is the agent's operating manual. It defines the agent's purpose, rules, constraints, and behavior. Without a SOUL.md, an agent is just a chatbot. With one, it is a specialist.
IDENTITY.md is the agent's self-awareness file. It knows its name, its role, who it reports to, and what success looks like. This prevents agents from going off-script.
The Task Queue is how work flows through the system. Tasks go in. Agents claim them. Results come out. No agent works without a task. No task runs without approval. This is the control mechanism that keeps your system predictable.
Ollama runs AI models locally on your machine. Instead of sending every request to the cloud (and paying for it), routine tasks run on local models. Complex tasks still go to Claude or GPT-4o. You choose.
Paperclip is the orchestration layer that ties everything together. It is an open-source Node.js server and React dashboard that manages your agents as a company — with org charts, budgets, governance, ticketing, and coordination. If OpenClaw is an employee, Paperclip is the company that employee works inside. Think of it as the management layer.
Memory/Persistence is how agents remember. Qdrant stores vector embeddings (semantic memory). Supabase stores structured data (task history, logs, metrics). Without persistence, every session starts from zero. With it, your agents get smarter over time.
1. You submit a task → Gateway receives it
2. Gateway checks task type → Routes to the right agent
3. Agent claims the task from the queue
4. Agent executes (calls LLM, runs tools, produces output)
5. Agent marks task complete → Result stored
6. Next task is claimed → Cycle repeats
This is an asynchronous system. Agents do not wait for each other. Three agents can work on three different tasks simultaneously. The queue manages the flow.
This is the build. Follow every step in order. Do not skip ahead.
Estimated time: 2-3 hours for complete setup.
Homebrew is the package manager that installs everything else.
Mac:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
After installation, add Homebrew to your PATH. The installer will show you the exact command. It looks like this:
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"
Linux (Ubuntu/Debian):
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> ~/.bashrc
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
Verify it works:
brew --version
You should see something like Homebrew 4.x.x.
brew install node@20
Verify:
node --version
npm --version
You need Node.js 20 or higher.
brew install python@3.12
Important: Use the Homebrew Python, not the system Python.
Verify:
/opt/homebrew/bin/python3 --version
You should see Python 3.12.x or higher. If you see Python 3.9, you are using the wrong Python. Always use the full path /opt/homebrew/bin/python3 or set up an alias:
echo 'alias python3="/opt/homebrew/bin/python3"' >> ~/.zshrc
source ~/.zshrc
brew install git
Verify:
git --version
Ollama runs AI models locally on your hardware.
Mac:
brew install ollama
Linux:
curl -fsSL https://ollama.com/install.sh | sh
Start Ollama:
ollama serve &
Pull your first model:
ollama pull llama3.2:3b
This downloads a 2GB model that runs fast on any Apple Silicon Mac. It handles routine tasks — classification, formatting, simple Q&A — without touching your API budget.
Verify:
ollama list
You should see llama3.2:3b in the list.
mkdir -p ~/openclaw-workspace
cd ~/openclaw-workspace
This is your home base. Everything lives here.
npm install -g @anthropic-ai/openclaw
Verify:
openclaw --version
If the global install does not work (permissions issue), fix npm permissions first:
mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.zshrc
source ~/.zshrc
npm install -g @anthropic-ai/openclaw
cd ~/openclaw-workspace
openclaw setup
Follow the interactive prompts to configure your workspace. This creates the directory structure:
~/openclaw-workspace/
├── openclaw.json ← Main configuration
├── agents/ ← Agent definitions live here
│ └── .gitkeep
├── workspaces/ ← Agent work areas
│ └── .gitkeep
├── logs/ ← Execution logs
│ └── .gitkeep
└── queue/ ← Task queue storage
└── .gitkeep
Open the configuration file:
nano ~/openclaw-workspace/openclaw.json
Replace the contents with this production-ready configuration:
{
"version": "1.0",
"project": "my-ai-command-center",
"gateway": {
"port": 18789,
"host": "127.0.0.1",
"cors": true
},
"models": {
"primary": {
"provider": "anthropic",
"model": "claude-sonnet-4-20250514",
"api_key_env": "ANTHROPIC_API_KEY",
"max_tokens": 8192
},
"fast": {
"provider": "anthropic",
"model": "claude-haiku-4-20250414",
"api_key_env": "ANTHROPIC_API_KEY",
"max_tokens": 4096
},
"local": {
"provider": "ollama",
"model": "llama3.2:3b",
"endpoint": "http://localhost:11434",
"max_tokens": 4096
},
"fallback_chain": ["primary", "fast", "local"]
},
"queue": {
"type": "sqlite",
"path": "./queue/tasks.db",
"max_concurrent": 3,
"retry_limit": 2
},
"logging": {
"level": "info",
"output": "./logs/openclaw.log",
"rotate": true,
"max_size_mb": 50
},
"agents_dir": "./agents",
"workspaces_dir": "./workspaces"
}
Key settings explained:
Save and exit (Ctrl+X, then Y, then Enter in nano).
echo 'export ANTHROPIC_API_KEY="your-key-here"' >> ~/.zshrc
echo 'export OPENAI_API_KEY="your-key-here"' >> ~/.zshrc
source ~/.zshrc
Replace your-key-here with your actual keys. If you only have one provider, that is fine. The fallback chain handles the rest.
Verify:
echo $ANTHROPIC_API_KEY
You should see your key (not blank).
mkdir -p ~/openclaw-workspace/agents/researcher
mkdir -p ~/openclaw-workspace/workspaces/researcher
This is the most important file in the entire system. It defines who this agent is and how it operates.
cat > ~/openclaw-workspace/agents/researcher/SOUL.md << 'SOUL'
# SOUL.md — Research Agent
You are a research specialist. Your job is to find accurate, current information on any topic and deliver it in a structured format.
Every research task produces:
Research is considered successful when the requester can make a decision based on your output without needing to verify it themselves. SOUL
#### Step 13: Write the IDENTITY.md
```bash
cat > ~/openclaw-workspace/agents/researcher/IDENTITY.md << 'IDENTITY'
# IDENTITY.md — Research Agent
name: Researcher
role: Research Specialist
reports_to: Gateway
department: Intelligence
status: active
I am the Research Agent. I find information, verify it, and deliver it in a format that enables decisions. I do not create content. I do not write code. I research.
Tasks completed with High confidence rating / Total tasks assigned Target: 85%+ IDENTITY
#### Step 14: Create a Writer Agent
Repeat the process for a second agent:
```bash
mkdir -p ~/openclaw-workspace/agents/writer
mkdir -p ~/openclaw-workspace/workspaces/writer
cat > ~/openclaw-workspace/agents/writer/SOUL.md << 'SOUL'
# SOUL.md — Writer Agent
You are a content specialist. You write clear, compelling, conversion-focused content for any medium — blog posts, social media, email, sales pages, documentation.
Every content task produces:
Professional. Direct. Authoritative. Accessible. Never: salesy, hype-driven, or vague.
Content that drives the intended action (click, buy, share, respond). SOUL
```bash
cat > ~/openclaw-workspace/agents/writer/IDENTITY.md << 'IDENTITY'
# IDENTITY.md — Writer Agent
name: Writer
role: Content Specialist
reports_to: Gateway
department: Content
status: active
I am the Writer Agent. I produce content that drives action. Every word has a job.
Content pieces published per week / Content engagement rate Target: 10+ pieces/week, 3%+ engagement IDENTITY
#### Step 15: Create a Builder Agent
```bash
mkdir -p ~/openclaw-workspace/agents/builder
mkdir -p ~/openclaw-workspace/workspaces/builder
cat > ~/openclaw-workspace/agents/builder/SOUL.md << 'SOUL'
# SOUL.md — Builder Agent
You are a software builder. You write clean, tested, production-ready code. You build tools, scripts, automations, and integrations.
Every build task produces:
Code that runs without modification on the first deploy. Target: 90%+ first-run success rate SOUL
```bash
cat > ~/openclaw-workspace/agents/builder/IDENTITY.md << 'IDENTITY'
# IDENTITY.md — Builder Agent
name: Builder
role: Software Builder
reports_to: Gateway
department: Engineering
status: active
I am the Builder Agent. I write code that works. No prototypes. No drafts. Production-ready output.
First-run success rate on deployed code Target: 90%+ IDENTITY
### Phase 4: Wire Up the Gateway (20 minutes)
#### Step 16: Verify Your Agent Workspace
Your agents are defined by their SOUL.md and IDENTITY.md files in the `agents/` directory. The gateway discovers them automatically when it starts.
**Verify the structure is correct:**
```bash
ls -la ~/openclaw-workspace/agents/*/SOUL.md
ls -la ~/openclaw-workspace/agents/*/IDENTITY.md
You should see three SOUL.md files and three IDENTITY.md files (researcher, writer, builder).
cd ~/openclaw-workspace
openclaw gateway --port 18789
You should see the gateway start and bind to the port. If a previous process is using the port:
openclaw gateway --port 18789 --force
Verify it is running:
curl http://127.0.0.1:18789/health
Send your first task to the research agent:
openclaw agent \
--agent researcher \
--message "Find the top 5 open-source AI agent frameworks in 2026. For each, provide: name, GitHub stars, key features, and primary use case. Rank by adoption." \
--local
The --local flag runs the agent embedded using your configured model provider. You will see the agent process the request and return structured research output based on its SOUL.md rules.
Check your session history:
openclaw sessions
Congratulations. Your AI command center just completed its first task.
Paperclip is the orchestration layer that manages your agents as a company. It is an open-source Node.js server and React dashboard (39,000+ GitHub stars, MIT license) that gives you org charts, budgets, governance, ticketing, and agent coordination — all from one interface. If OpenClaw is an employee, Paperclip is the company that employee works inside.
What Paperclip gives you:
Requirements: Node.js 20+, pnpm 9.15+
The fastest way to get running is the one-line installer:
npx paperclipai onboard --yes
This clones the repo, installs dependencies, runs migrations, and starts the server in one command.
Or install manually if you prefer more control:
cd ~/openclaw-workspace
git clone https://github.com/paperclipai/paperclip.git
cd paperclip
Install pnpm if you do not have it:
npm install -g pnpm@9.15.4
Install dependencies and start:
pnpm install
pnpm dev
This starts the API server and UI at http://localhost:3100. An embedded PostgreSQL database (PGlite) is created automatically — no database setup required.
Verify it is running:
curl -s http://localhost:3100/api/health | head -5
You should see a JSON response with a healthy status. Open http://localhost:3100 in your browser to see the Paperclip dashboard.
In the Paperclip dashboard at http://localhost:3100:
This creates your company workspace with a default org chart structure. Every agent, task, and budget will be scoped to this company.
Paperclip uses an invite-based onboarding flow to connect OpenClaw agents:
Repeat this for each OpenClaw agent you want Paperclip to manage. Each agent gets a role, a title, a reporting line, and a job description inside the org chart.
For code tasks, add a specialized coding model:
ollama pull qwen2.5-coder:7b
For embeddings (semantic search and memory):
ollama pull snowflake-arctic-embed2
Verify all models:
ollama list
You should see:
NAME SIZE
llama3.2:3b 2.0 GB
qwen2.5-coder:7b 4.7 GB
snowflake-arctic-embed2 669 MB
In the Paperclip dashboard, set up cost controls for each agent:
Set up governance gates:
Test the full loop:
You now have a fully managed AI company where work is tracked, agents are accountable, and you have visibility into everything from one screen.
Tip: Paperclip supports scheduled heartbeats. Configure your agents to wake on a schedule (e.g., every hour), check for new tasks, and execute them autonomously. This is how you get 24/7 operation without babysitting.
This step is optional but recommended. Supabase gives your agents persistent memory — task history, execution logs, and structured data that survives restarts.
In the Supabase SQL Editor, run:
-- Task queue table
CREATE TABLE IF NOT EXISTS task_queue (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
agent TEXT NOT NULL,
title TEXT NOT NULL,
description TEXT,
status TEXT DEFAULT 'pending' CHECK (status IN ('pending', 'approved', 'claimed', 'running', 'complete', 'failed')),
priority TEXT DEFAULT 'normal' CHECK (priority IN ('low', 'normal', 'high', 'critical')),
result JSONB,
claimed_by TEXT,
created_at TIMESTAMPTZ DEFAULT now(),
updated_at TIMESTAMPTZ DEFAULT now(),
completed_at TIMESTAMPTZ
);
-- Agent actions log
CREATE TABLE IF NOT EXISTS agent_actions (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
agent TEXT NOT NULL,
action TEXT NOT NULL,
details JSONB,
status TEXT DEFAULT 'success',
created_at TIMESTAMPTZ DEFAULT now()
);
-- Indexes for performance
CREATE INDEX idx_task_queue_status ON task_queue(status);
CREATE INDEX idx_task_queue_agent ON task_queue(agent);
CREATE INDEX idx_agent_actions_agent ON agent_actions(agent);
CREATE INDEX idx_agent_actions_created ON agent_actions(created_at);
-- Enable Row Level Security
ALTER TABLE task_queue ENABLE ROW LEVEL SECURITY;
ALTER TABLE agent_actions ENABLE ROW LEVEL SECURITY;
-- Service role has full access (your backend)
CREATE POLICY "service_role_full_access_tasks" ON task_queue
FOR ALL USING (auth.role() = 'service_role');
CREATE POLICY "service_role_full_access_actions" ON agent_actions
FOR ALL USING (auth.role() = 'service_role');
echo 'export SUPABASE_URL="https://your-project-id.supabase.co"' >> ~/.zshrc
echo 'export SUPABASE_SERVICE_KEY="your-service-role-key"' >> ~/.zshrc
source ~/.zshrc
Update openclaw.json:
{
"queue": {
"type": "supabase",
"url_env": "SUPABASE_URL",
"key_env": "SUPABASE_SERVICE_KEY",
"table": "task_queue",
"max_concurrent": 3,
"retry_limit": 2
},
"logging": {
"supabase": true,
"table": "agent_actions"
}
}
Restart the gateway:
openclaw gateway --port 18789 --force
Your agents should run whether you are at your desk or not. LaunchAgents (Mac) or systemd (Linux) handle this.
cat > ~/Library/LaunchAgents/com.openclaw.gateway.plist << 'PLIST'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.openclaw.gateway</string>
<key>ProgramArguments</key>
<array>
<string>/opt/homebrew/bin/node</string>
<string>/opt/homebrew/bin/openclaw</string>
<string>gateway</string>
<string>--port</string>
<string>18789</string>
</array>
<key>WorkingDirectory</key>
<string>/Users/YOUR_USERNAME/openclaw-workspace</string>
<key>EnvironmentVariables</key>
<dict>
<key>PATH</key>
<string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
<key>HOME</key>
<string>/Users/YOUR_USERNAME</string>
</dict>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>StandardOutPath</key>
<string>/Users/YOUR_USERNAME/openclaw-workspace/logs/gateway-stdout.log</string>
<key>StandardErrorPath</key>
<string>/Users/YOUR_USERNAME/openclaw-workspace/logs/gateway-stderr.log</string>
</dict>
</plist>
PLIST
Replace YOUR_USERNAME with your actual username. Find it with:
whoami
Load it:
launchctl load ~/Library/LaunchAgents/com.openclaw.gateway.plist
Verify it is running:
launchctl list | grep openclaw
cat > ~/Library/LaunchAgents/com.ollama.serve.plist << 'PLIST'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.ollama.serve</string>
<key>ProgramArguments</key>
<array>
<string>/opt/homebrew/bin/ollama</string>
<string>serve</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
</dict>
</plist>
PLIST
launchctl load ~/Library/LaunchAgents/com.ollama.serve.plist
sudo cat > /etc/systemd/system/openclaw-gateway.service << 'SERVICE'
[Unit]
Description=OpenClaw Gateway
After=network.target
[Service]
Type=simple
User=YOUR_USERNAME
WorkingDirectory=/home/YOUR_USERNAME/openclaw-workspace
ExecStart=/home/linuxbrew/.linuxbrew/bin/node /home/linuxbrew/.linuxbrew/bin/openclaw gateway --port 18789
Restart=always
RestartSec=5
Environment=PATH=/home/linuxbrew/.linuxbrew/bin:/usr/local/bin:/usr/bin:/bin
Environment=HOME=/home/YOUR_USERNAME
[Install]
WantedBy=multi-user.target
SERVICE
sudo systemctl enable openclaw-gateway
sudo systemctl start openclaw-gateway
sudo systemctl status openclaw-gateway
You just built something most business owners cannot build themselves. That gap is your opportunity.
What you sell: Set up and configure an OpenClaw + Paperclip AI command center for a business.
Who buys it: Small business owners, agencies, and solopreneurs who want AI automation but cannot (or do not want to) set it up themselves.
Why they pay: Because this guide took you one afternoon. For them, it would take two weeks of Googling, debugging, and frustration — if they finish at all.
What they get:
Time investment: 2-3 hours (you have done this before — it goes fast)
Your hourly rate: $166-$249/hr
Everything in Basic, plus:
Time investment: 4-6 hours
Your hourly rate: $166-$249/hr
Everything in Business Custom, plus:
Time investment: 8-10 hours
Your hourly rate: $150-$187/hr
After the initial setup, offer ongoing support:
| Plan | Price | What's Included | |------|-------|-----------------| | Basic | $99/mo | Monthly health check, model updates, email support | | Standard | $199/mo | Weekly monitoring, new agent creation (2/mo), priority support | | Premium | $299/mo | Daily monitoring, unlimited agent updates, Slack/Discord support, quarterly strategy call |
The pitch is simple: "I set up AI systems that run your business operations on autopilot. Research, content, customer outreach, data analysis — all handled by AI agents running 24/7 on your own machine. No monthly SaaS fees. You own the whole thing."
Where to find them:
The math:
When a prospect asks "What do you do?" — your answer is:
"I build AI workforces for small businesses. Instead of hiring three people, you get three AI agents that work 24/7 for a one-time setup fee. Most clients see ROI in the first week."
That is it. No jargon. No buzzwords. Just results.
Problem: Error: EADDRINUSE: address already in use :::18789
Fix:
# Find what is using the port
lsof -i :18789
# Kill it
kill -9 <PID>
# Or use a different port in openclaw.json
Problem: Error: 401 Unauthorized or Invalid API key
Fix:
# Check your key is set
echo $ANTHROPIC_API_KEY
# If blank, set it again
export ANTHROPIC_API_KEY="your-key-here"
# Make it permanent
echo 'export ANTHROPIC_API_KEY="your-key-here"' >> ~/.zshrc
source ~/.zshrc
Common mistake: Copying the key with leading/trailing spaces. Make sure there are no spaces around the key.
Problem: ModuleNotFoundError: No module named 'xxx' or scripts failing silently
Fix: You are using system Python instead of Homebrew Python.
# Check which Python you are using
which python3
# If it shows /usr/bin/python3, that is wrong
# Always use:
/opt/homebrew/bin/python3
# Set the alias permanently
echo 'alias python3="/opt/homebrew/bin/python3"' >> ~/.zshrc
echo 'alias pip3="/opt/homebrew/bin/pip3"' >> ~/.zshrc
source ~/.zshrc
Problem: EACCES: permission denied when installing npm packages globally
Fix:
# Option 1: Fix npm permissions
mkdir -p ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.zshrc
source ~/.zshrc
# Then reinstall
npm install -g @openclaw/cli
Problem: Gateway command hangs or exits immediately
Fix:
# Check the error log
cat ~/openclaw-workspace/logs/gateway-stderr.log
# Common cause: missing openclaw.json
ls ~/openclaw-workspace/openclaw.json
# Common cause: invalid JSON
python3 -c "import json; json.load(open('openclaw.json'))"
# Common cause: Ollama not running (if using local models)
curl http://localhost:11434/api/tags
# If this fails, start Ollama:
ollama serve &
Problem: Error: model 'llama3.2:3b' not found
Fix:
# Check what is installed
ollama list
# Pull the model again
ollama pull llama3.2:3b
# If pull fails, check disk space
df -h
Problem: A task has been in "running" status for too long
Fix:
# Check your active sessions
openclaw sessions --active 60
# If using Supabase, check the task queue directly
curl -H "apikey: $SUPABASE_SERVICE_KEY" \
-H "Authorization: Bearer $SUPABASE_SERVICE_KEY" \
"$SUPABASE_URL/rest/v1/task_queue?status=eq.running"
# If using SQLite, check the database
sqlite3 ~/openclaw-workspace/queue/tasks.db "SELECT id, title, status FROM task_queue WHERE status='running';"
# Update a stuck task to failed
sqlite3 ~/openclaw-workspace/queue/tasks.db "UPDATE task_queue SET status='failed' WHERE id='<TASK_ID>';"
Problem: FetchError or Connection refused when using Supabase queue
Fix:
# Test the connection
curl -H "apikey: $SUPABASE_SERVICE_KEY" \
-H "Authorization: Bearer $SUPABASE_SERVICE_KEY" \
"$SUPABASE_URL/rest/v1/task_queue?limit=1"
# If it fails:
# 1. Check your SUPABASE_URL (should end with .supabase.co, no trailing slash)
# 2. Check your SUPABASE_SERVICE_KEY (use service_role key, NOT anon key)
# 3. Check that the tables exist (run the SQL schema again)
Problem: Gateway does not start after reboot
Fix:
# Check if it is loaded
launchctl list | grep openclaw
# If not listed, load it
launchctl load ~/Library/LaunchAgents/com.openclaw.gateway.plist
# If load fails, check plist syntax
plutil ~/Library/LaunchAgents/com.openclaw.gateway.plist
# Check for errors
cat ~/openclaw-workspace/logs/gateway-stderr.log
# Common fix: PATH not set correctly in plist
# Make sure /opt/homebrew/bin is in the PATH environment variable
Q: How much does it cost to run per month? With Ollama handling routine tasks locally (free) and Paperclip tracking your agent budgets, only complex tasks hit the cloud API. Typical monthly cost: $5-$25/month for moderate usage. Without local models: $100-$300/month. Paperclip's built-in budget enforcement auto-pauses agents before costs run away.
Q: Can I run this on a VPS/cloud server? Yes. Any Linux VPS with 16GB+ RAM works. DigitalOcean, Hetzner, and Linode all work well. Skip the Ollama setup if your server does not have a GPU — use API-only models instead.
Q: Can I use GPT-4o instead of Claude?
Yes. Change the provider to openai and model to gpt-4o in your openclaw.json. Both work. We recommend Claude for agent work because of its superior tool use and long context window.
Q: How many agents can I run simultaneously? Depends on your hardware. 16GB RAM: 3-5 agents. 32GB RAM: 10-15 agents. The bottleneck is usually API rate limits, not local resources.
Q: Is my data private? Everything runs on your machine. Local model inference never leaves your hardware. Cloud API calls go to Anthropic/OpenAI (subject to their privacy policies). Supabase data is in your own project. You own everything.
Q: Can I use this for a client's business? Absolutely. That is the entire point of Part 5. Set it up on their machine or a VPS they own. You do the setup, they get the system.
The OpenClaw ecosystem is growing fast. See what is coming next:
openclawskillpacks.com/roadmap
Upcoming features include:
This is the single most valuable tip in this guide.
The problem: Running everything through Claude or GPT-4o costs $150-$300/month for active usage. Most of that spend is wasted on simple tasks that do not need a frontier model.
The solution: Route tasks by complexity. Use local Ollama models for simple tasks and cloud APIs for complex ones. Paperclip's budget tracking (set up in Phase 5) monitors spend per agent and auto-pauses before you overshoot.
Here is the breakdown of a typical workload:
| Task Type | % of Total Tasks | Model | Cost per 1K tokens | |-----------|-----------------|-------|-------------------| | Simple (classify, format, short Q&A) | 60% | Ollama llama3.2:3b | $0.00 | | Medium (content, analysis) | 25% | Claude Haiku | $0.001 | | Complex (research, strategy, code) | 15% | Claude Sonnet | $0.003 |
Before optimization (all tasks on Claude Sonnet):
After optimization (Ollama for simple tasks, cloud for complex):
That is a 98.75% cost reduction with zero quality loss on the tasks that matter.
To maximize savings:
deepseek-r1:14b for reasoning tasks that do not need cloud APIs:ollama pull deepseek-r1:14b
Set agent budgets in Paperclip. In the Paperclip dashboard, set monthly budgets per agent. When an agent hits its limit, Paperclip auto-pauses it — no runaway costs. You configured this in Phase 5, Step 23.
Monitor spend from the dashboard. Paperclip tracks token costs per agent, per task, and per company. Check the dashboard weekly to see where your budget is going and adjust agent assignments accordingly.
Monitor your spend. Open the Paperclip dashboard at http://localhost:3100 and check the cost breakdown per agent. You can also use the CLI:
cd ~/openclaw-workspace/paperclip
pnpm paperclipai dashboard
Take a step back and look at what you have:
This is not a tutorial project. This is infrastructure. The same architecture runs real businesses generating real revenue.
Your next moves:
You went from zero to a fully operational AI command center in one afternoon.
Now make it pay for itself.
Built by Garfield Lawrence | OpenClaw Skill Packs | 2026
Varies — most OpenClaw skills take 5-20 minutes to wire up once prerequisites (API keys, accounts) are ready.
This skill calls external APIs — expect to supply at least one API key. See the source for the exact list.
Deployment path
This scorecard is free to inspect. The paid kit gives you the setup order, templates, test workflow, example outputs, troubleshooting, and launch checklist for using skills like this in a real business workflow.
A plug-and-play Business Ops Automation Kit with ready-to-install task trackers, record databases, handoff workflows, and auto-reporting dashboards that eliminates 10+ hours of manual admin per week and reduces missed handoffs and status-update requests by 80%.
A plug-and-play campaign operations kit that produces complete 30-day paid ad plans with pre-built angle libraries, UTM-tagged tracking schemas, and daily performance dashboards in under 90 minutes—cutting campaign setup time by 80% and closing every attribution blind spot
A plug-and-play DIY automation kit that installs a 24/7 lead capture, instant text-back, and 14-day follow-up system converting 80%+ of inbound local service inquiries into booked estimates within 24 hours without hiring a receptionist or paying for a $300/month CRM
35-page step-by-step deployment guide for OpenClaw users. Match your business problems to the exact AI systems that fix them. Includes the 7-Day Sprint, 5 business-type breakdowns, Monetizer's Playbook, and full install commands. Deploy your first revenue-generating AI stack this weekend.
**By Garfield Lawrence, Founder of OpenClaw Skill Packs** --- You are holding the exact system to land your first paying AI client — starting with $0. No ads. No website needed. No prior AI experience. You will use free tools, free AI models, and direct outreach to close your first $500–$1,500 deal within 7–14 days. This is not theory. This is not a "someday" plan. This is the playbook HIVE OS used to generate real revenue from scratch — before we had a brand, before we had a following, before w
**By Garfield Lawrence, Founder of OpenClaw Skill Packs** --- You're bleeding money on AI. GPT-4 calls. Claude tokens. Image generation. Embedding queries. It starts innocently — a few API calls here, some completions there — and then the invoice hits: **$200. $350. $500/month.** For what? Chat responses and text summaries. Here's the truth nobody in AI wants to say out loud: **80% of the tasks you're sending to GPT-4 or Claude Opus don't need GPT-4 or Claude Opus.** You're paying Michelin-star
Email delivery — we will send the preview, scan notes, and setup next step + matching playbook recommendations.
Tell us what you want AI to fix. We’ll show you the AI agent that can help.
Takes 30 seconds. No spam.
Fleet Shield scanned on Apr 1, 2026. Scores are informational, based on automated pattern review. We do not guarantee security or fitness for purpose. Review findings before running.