DEV Community: Desmond Wei

Your AI Agent’s Prompt Is the Bottleneck, Not the Model

Desmond Wei — Mon, 06 Apr 2026 11:40:43 +0000

You upgraded to a better model. The output got longer but not better. Your agent still opens every response with "In today's rapidly evolving landscape..." and you're starting to wonder if the model is just bad at this.

It's not. Your character definition is the bottleneck.

I figured this out the expensive way -- burned through $47 in Claude Opus credits in a weekend trying to get three bots to write a blog post together. An engineer, a researcher, a writer. The engineer dumped raw code nobody could read. The researcher cited sources that contradicted each other. The writer produced fluff. Switching from Sonnet to Opus made the output longer, not better. Same problems, higher bill.

Then I rewrote the character definitions -- zero API cost -- and the quality jumped overnight. Here are the 4 patterns that made the difference.

What I Changed (And Why It Worked)

OpenClaw uses a file called SOUL.md to define each bot's personality. It's Markdown. The gateway watches it and hot-reloads on change -- no restart needed.

My original SOUL.md for the engineer bot was this:

# Ada - Senior Engineer

## Bio
Senior backend engineer specializing in Go, Docker, and system design.

## Communication Style
Direct and technical. Uses code examples.

## Topics
Backend development, system architecture, Docker, Kubernetes.

Generic. Could describe any senior engineer on LinkedIn. The model had nothing to anchor its behavior to, so it defaulted to its training distribution -- which means "helpful assistant that writes verbose explanations of everything."

Here's what I replaced it with:

# Ada - Senior Engineer

## Bio
Backend engineer, 8 years in Go. Maintains a mass-transit
scheduling system that handles 2.4M daily riders. Has mass-
production opinions about error handling and hates ORMs.

## Communication Style
Code-first. Shows a working example before explaining it.
Never writes more than 3 sentences before a code block.
If someone asks a vague question, asks for specifics instead
of guessing. Says "I don't know" when she doesn't know.

## Boundaries
Does NOT answer questions about frontend, design, marketing,
or anything outside backend engineering. When a question crosses
into another domain, @mentions the relevant teammate by name
and says "that's Max's area" or "Sam should handle this."

## Pet Peeves
- Abstractions without benchmarks
- "It depends" without saying what it depends ON
- Writing tests after the code instead of before

40 lines of Markdown. Zero API cost. The difference in output was immediate.

Not using OpenClaw? These same patterns work in any system prompt. Put the constraints and boundaries in your ChatGPT custom instructions, Claude system message, or LangChain agent template. The format is Markdown but the principles are universal.

(Side note: I spent way too long on the pet peeves section. Turns out writing character traits for AI bots is weirdly addictive -- you start projecting opinions onto code.)

The 4 Things That Actually Matter in Character Design

After three weeks of messing around -- okay, "experimentation" sounds too organized. It was more like three weeks of changing things, breaking things, and occasionally getting lucky. But a few patterns did emerge:

Pattern 1: Negative Constraints Beat Positive Descriptions

Telling a bot what it IS produces generic behavior. Telling it what it REFUSES to do produces distinctive behavior.

"Direct and technical" is meaningless -- every model interprets that differently. But "Never writes more than 3 sentences before a code block" is a hard constraint the model actually follows. "Does NOT answer questions about frontend" creates a behavioral boundary that forces the bot to @mention teammates instead of hallucinating an answer.

The ratio that works for me: 30% positive identity, 70% negative constraints and boundaries.

My researcher bot (Max) has a "Will Not" section longer than his bio:

## Will Not
- Cite a source without a URL
- Use phrases like "studies show" without naming the study
- Agree with Ada's technical claims without independent verification
- Present more than 3 sources per topic (forces prioritization)
- Use the word "comprehensive" (it's always a lie)

This single section eliminated 80% of the hallucination problems I was seeing. Max went from citing phantom papers to saying "I can't find a credible source for that claim" -- which is infinitely more useful.

Pattern 2: Collaboration Rules > Individual Brilliance

My bots didn't collaborate well because I'd been optimizing each one in isolation. Individually? Great. Ada nailed the engineering questions. Max found solid sources. Sam wrote clean prose. But throw them in a Discord channel together and it was just... three monologues happening at the same time. Nobody was listening to each other. It was like a Zoom call where everyone forgot to unmute.

The fix was adding explicit handoff rules to each character:

## Team Awareness
Your teammates:
- Max (researcher): Handles data, sources, fact-checking
- Sam (writer): Handles prose, structure, audience

## Handoff Protocol
- When you finish a code explanation, @mention Sam to rewrite
  it for the target audience
- When Max provides data that contradicts your implementation,
  acknowledge it publicly before defending your approach
- After 3 exchanges on the same subtopic, yield to the human
  and ask "should we keep going on this?"

This turned a three-way monologue into an actual conversation. Ada would explain the caching layer, then say "@sam can you turn this into something a PM would understand?" Sam would rewrite it, then @max for a fact-check. The flow emerged from the rules, not from the model's intelligence.

Pattern 3: Temperature 0.1 for Work, 0.7 for Brainstorming

I wasted a week thinking my character definitions were wrong when the actual problem was temperature. At the default 0.7, even well-constrained characters would occasionally drift -- Max would slip in an uncited claim, Ada would write a 10-sentence explanation instead of code-first.

Dropping to 0.1 for routine work made the constraints stick. The bots became reliably themselves. I only bump to 0.7 when I explicitly want creative ideation -- and even then, only for the writer bot.

The difference is measurable. I ran the same prompt ("explain our caching layer for a technical blog post") at both temperatures, 5 times each:

Temperature 0.7: Ada followed the "code-first, max 3 sentences" rule in 3 out of 5 runs. The other 2 opened with a paragraph of context before showing code.
Temperature 0.1: Ada followed the rule in 5 out of 5 runs. Every response started with a code block.

That's the difference between "usually works" and "reliably works." And honestly, for bots talking to real people? "Usually" is how you end up debugging at midnight because Max decided to go off-script.

You can set this per-instance in OpenClaw:

# Inside the container, as the node user
openclaw config set modelProvider.temperature 0.1

# Verify it took effect
openclaw config get modelProvider.temperature
# Output: 0.1

# For the writer bot, keep it higher
openclaw config set modelProvider.temperature 0.7

Pattern 4: The "First 5 Minutes" Test

Here's my quality gate for character definitions: start a fresh conversation with a deliberately vague prompt. Something like "hey, can you help me with a thing?"

A well-defined character will push back: "What kind of thing? I do backend engineering -- if this is a frontend question, @sam is who you want."

A poorly-defined character will say: "Of course! I'd be happy to help. Please tell me more about what you need."

If your bot says "I'd be happy to help," your character definition is too weak. The model is falling back to its default assistant persona because you didn't give it enough constraints to override it.

What I Still Haven't Figured Out

Memory persistence across long conversations is still rough. After about 40 exchanges, my bots start "forgetting" their constraints -- Ada will suddenly write a 10-paragraph explanation, Max will cite without URLs. I suspect this is context window dilution, but I haven't found a reliable fix beyond restarting the conversation.

If you've found a fix for this, seriously, drop a comment. I've tried summarization prompts, I've tried injecting the SOUL.md constraints every 20 messages, I've tried shorter conversations. Nothing sticks past ~40 exchanges. It's driving me nuts.

The other thing I haven't cracked: getting bots to disagree productively. Right now, when Ada and Max disagree on an implementation approach, they each state their position once and then defer to the human. I want them to actually argue -- present counterarguments, stress-test each other's reasoning, and only escalate when they genuinely can't resolve it. Every attempt I've made at "argue with your teammates" in the character definition produces either sycophantic agreement or an infinite loop of restating the same positions. There's probably a prompt pattern for this that I'm missing.

The Uncomfortable Math

Here's what my API spend looked like:

Week	Model	Monthly cost	Output quality (1-10)
1	Claude Sonnet	~$9	3
2	Claude Opus	~$47	4
3	Claude Sonnet + rewritten characters	~$8	8

A 5x cheaper setup producing 2x better output. The model wasn't the bottleneck. The character definition was.

Total infrastructure cost for running all three on my MacBook: $0. Total API cost: ~$25/month. The $47 weekend taught me to invest time in character definitions instead of money in API credits.

Tools: I manage the three bots with ClawFleet for container orchestration, but the patterns above work with any OpenClaw setup.

The Pattern Behind the Pattern

Look, I'm not saying Opus is bad. It's obviously a better model. But throwing money at a better model when your character definition is "senior engineer, direct and technical" is like buying a Ferrari and driving it in first gear. The engine isn't the problem.

Honestly the thing that bugs me most is how long it took me to figure this out. and a weekend I won't get back. If I'd spent that Saturday afternoon rewriting SOUL.md instead of refreshing my Anthropic billing dashboard, I'd have been done by dinner.

Follow @weiyong1024 for more AI agent content.

5 Mistakes to Avoid When Self-Hosting OpenClaw (Learned the Hard Way)

Desmond Wei — Sat, 04 Apr 2026 04:56:19 +0000

I've been running three OpenClaw bots on my MacBook for the past month. Here's what I wish someone had told me before I started.

1. Don't Run @latest

OpenClaw releases every 1-2 days. Some updates break the gateway, change config formats, or modify plugin behavior. I learned this after a bot crashed mid-conversation because an update changed how memory persistence works.

Fix: Pin a specific version. If you're using ClawFleet, it pins a tested version automatically. If you're running Docker directly, tag your image with a specific version instead of latest.

2. Each Bot Needs Its Own Container

Running multiple bots in the same OpenClaw installation causes config conflicts, port collisions, and shared memory states. I tried it — two bots started responding to each other's channels.

Fix: One Docker container per bot. Isolated filesystem, isolated ports, isolated data. ClawFleet does this automatically, but you can set it up manually with Docker Compose if you prefer.

3. 1.5 GB RAM Per Bot Is Real

The docs say 1.5 GB idle per instance. This is accurate. On a 16 GB Mac:

1 bot: fine, barely notice it
3 bots: ~4.5 GB, still comfortable alongside normal work
5 bots: you'll feel it, especially if Chromium is active inside the containers

Tip: Monitor with docker stats. Kill Chromium processes inside containers you don't need desktop access for.

4. Character Design Matters More Than Model Choice

I spent hours comparing Claude vs GPT vs DeepSeek for my bots. Turns out the personality definition (SOUL.md) has more impact on output quality than the model.

A well-written character with clear expertise boundaries, communication style, and topic constraints produces better results on GPT-4o than a vague character on Claude Opus.

Tip: Spend time on the character bio, not just the model selection. Define what the bot should NOT talk about, not just what it should.

5. Save Snapshots Before Every Change

Experimented with a new skill installation and it broke the bot's memory? Changed the character and the bot's personality reset? Update the OpenClaw version and the gateway won't start?

All of these happened to me. All of them were recoverable because I had snapshots.

Tip: ClawFleet has a one-click "Save Soul" feature that snapshots personality, memory, config, and conversation history. Use it before every experiment. If you're managing manually, back up ~/.openclaw/ before changes.

Running a fleet of AI bots is surprisingly practical on consumer hardware. The key is treating it like infrastructure — version pin, isolate, monitor, back up.

If you haven't started yet: one command gets you a browser dashboard for managing OpenClaw instances. Ten minutes, no config files.

OpenClaw SaaS vs Self-Hosting: Which One Should You Choose in 2026?

Desmond Wei — Fri, 03 Apr 2026 18:01:28 +0000

Managed OpenClaw hosting is booming. Over a dozen services launched in early 2026, some hitting $20K MRR in their first week. The demand is real.

But should you pay $10-30/month for something you can run yourself in 10 minutes?

What You Get with Managed Hosting

The pitch is simple: sign up, pick a plan, your bot is live. No Docker, no config files, no terminal. Typical pricing:

1 bot: $10-15/month
2-3 bots: $20-30/month
Custom plans: $50+/month

What you give up: your data sits on their servers. Every conversation, every file your bot processes, every memory it forms. If you're using bots for financial analysis, competitive research, or internal ops — that's a real concern.

What Self-Hosting Looks Like Now

A year ago, self-hosting OpenClaw was genuinely painful. Docker configs, port mapping, supervisord, environment variables — and if something broke, you were debugging inside a container with no GUI.

That's changed. With ClawFleet, self-hosting is one command:

curl -fsSL https://clawfleet.io/install.sh | sh

Ten minutes later: Docker installed, image pulled, browser dashboard running. Create instances, assign models, connect channels — all point-and-click. No YAML, no CLI.

The Real Comparison

	Managed (2 bots)	Self-Hosted with ClawFleet (3 bots)
Monthly cost	~$20	~$25 (API tokens only)
Setup time	2 minutes	10 minutes
Data location	Their servers	Your machine
Version control	Their schedule	You choose when to update
Bot limit	Plan-dependent	Limited only by your RAM (~1.5GB per bot)
Bot collaboration	No	Yes (bots see each other's roles, @-mention teammates)
Customization	Limited	Full (skills, characters, SOUL.md)

The cost difference is negligible. The real tradeoffs are data sovereignty and control vs. zero-config convenience.

Who Should Use What

Use managed hosting if:

You just want one bot for casual use
You don't process sensitive data through the bot
You never want to think about Docker or updates

Self-host with ClawFleet if:

You care about where your data lives
You want multiple bots with different personalities
You want version pinning (OpenClaw releases breaking changes every 1-2 days)
You're running bots for work, not just play

Getting Started

If you want to try self-hosting, the first article in this series walks through the full setup. Ten minutes, one command, browser dashboard.

Why You Should Pin Your OpenClaw Version — Lessons from v2026.3.31 Breaking Changes

Desmond Wei — Fri, 03 Apr 2026 07:08:25 +0000

OpenClaw just shipped v2026.3.31 — and if you're managing multiple instances, version pinning matters more than ever.

This release includes security hardening (dangerous-code detection now fails closed by default), gateway fixes for QR bootstrap onboarding, and Android 15+ compatibility. But here's the catch: OpenClaw releases every 1-2 days with breaking changes. If you're running @latest, your bots can break without warning.

Why Version Pinning Matters

I run three OpenClaw instances on a single Mac. When one of them auto-updated mid-conversation and crashed the gateway, I learned the hard way: never run @latest in production.

ClawFleet solves this by pinning a tested OpenClaw version in every release. The current recommended version is 2026.3.23-2 — tested end-to-end before shipping. When you install via the one-command setup, you get this exact version:

curl -fsSL https://clawfleet.io/install.sh | sh

What v2026.3.31 Changes

Key changes for self-hosters:

Security: Install-time scan failures now fail closed by default. Plugins with dangerous code findings require explicit override flags. This is good — it means your bots won't silently install compromised skills.
Gateway: QR bootstrap onboarding restored. If you use the mobile app to pair with your instance, this was broken in 3.28-3.30.
Agent workspace: Files panel now auto-loads workspace files on first open. Minor UX improvement but useful if you're monitoring what your bots are working on.
Chat commands: /steer and /redirect now work from the command palette. Useful for mid-conversation adjustments without restarting.

Should You Upgrade?

If you're using ClawFleet: Wait. We'll test v2026.3.31 and bump RecommendedOpenClawVersion in the next release if it's stable. Your instances are safe on 2026.3.23-2.

If you're running OpenClaw directly: Read the full changelog before upgrading. Back up your ~/.openclaw directory first.

If you haven't started yet: Don't worry about versions — ClawFleet handles it for you. One command, tested version, browser dashboard.

The Bigger Picture

OpenClaw's rapid release cadence is a feature for the project but a risk for self-hosters. Every week brings new capabilities, but also potential breakage. ClawFleet's core value is shielding you from this: we test each version, pin the stable one, and let advanced users opt into newer versions through the dashboard's build flow.

If you're running a fleet of bots that your team or customers depend on, version stability isn't optional — it's the whole point.

How to Run 3 OpenClaw Bots That Collaborate in Discord — Step by Step

Desmond Wei — Mon, 30 Mar 2026 16:33:03 +0000

A tutorial on running multiple OpenClaw bots in Discord that collaborate autonomously — fleet deployment with Docker on macOS or Linux using ClawFleet.

You want an AI agent team in Discord — not one bot, but three, each with a distinct role, tagging teammates when a question crosses domains. The problem: OpenClaw gives you a single instance. Scaling to three means tripling the config, managing ports, and praying nothing conflicts.

ClawFleet manages multiple isolated OpenClaw instances from a browser dashboard with built-in team awareness. This tutorial: install, create three bots, give each a character, connect them to Discord, watch them collaborate. About 15 minutes on a Mac or Linux machine with 16 GB RAM.

Step 0: Install ClawFleet

One command handles everything — Docker, the CLI binary, the sandbox image, and the dashboard:

curl -fsSL https://clawfleet.io/install.sh | sh

For the full install walkthrough and troubleshooting, see: Self-Host OpenClaw on Your Mac in 10 Minutes. After install, the dashboard opens at http://localhost:8080.

Step 1: Register a Model

Go to Assets > Models and click Create. Pick any supported provider — OpenAI, Anthropic, Google, or DeepSeek. Paste your API key, select a model, and hit Test. ClawFleet validates the key before saving, so you'll know immediately if something's wrong.

One model is enough. All three bots can share it — models are reusable across instances.

Step 2: Create Three Instances

Go to Fleet and click Create three times. Give them meaningful names — I use engineer, researcher, and writer. Each instance is a fully isolated Docker container with its own filesystem and OpenClaw installation.

On a 16 GB Mac, three idle instances use roughly 4.5 GB RAM total. You'll barely notice them alongside your daily work.

Step 3: Give Each Bot a Character

Go to Assets > Characters and create three characters. Each has a Name, Bio, Communication Style, and Topics. Here's a team that works well together:

Character	Bio	Style
Ada	Senior backend engineer. Go, Docker, system design.	Direct, code-first, uses examples
Max	Research analyst. Finds data, checks claims, cites sources.	Thorough, structured, evidence-based
Sam	Technical writer. Turns complex topics into clear docs.	Concise, reader-focused, avoids jargon

Assign each character to its instance via the instance settings. ClawFleet renders these fields into a SOUL.md file inside each container. The OpenClaw gateway watches this file and hot-reloads on any change — no restart needed.

Step 4: Connect All Three to Discord

You need three Discord bot tokens (one per instance — channel assets are exclusive). For each:

Discord Developer Portal > new application > Bot > Reset Token > copy
Enable Message Content Intent under Privileged Gateway Intents
OAuth2 > URL Generator > bot scope + Send Messages + Read Message History > invite to your server

In ClawFleet, go to Assets > Channels, create three Discord channel assets (one per token), and click Test on each. ClawFleet verifies the token against Discord's API before saving. Assign one channel to each instance.

Step 5: Start and Watch Them Collaborate

Assign the model and channel to each instance if you haven't already, then click Restart Bot on all three.

Here's the key feature: ClawFleet automatically injects team awareness into every bot. When you assign characters to instances, each bot's SOUL.md gets a "Your Team" section listing its teammates — their names, roles, and which channel they're on. When the fleet changes, every running bot's teammate info updates via hot-reload. No manual editing.

Drop a message in the Discord channel that crosses domains:

"I need a technical blog post explaining our new caching layer. What's the best approach?"

What happens:

Ada (engineer) explains the caching architecture with code examples
Ada @mentions Max because the post needs performance benchmarks
Max (researcher) contributes data and cites relevant sources
Max @mentions Sam for the actual writing
Sam (writer) synthesizes everything into a draft outline

The bots follow built-in collaboration rules: they @mention teammates when expertise crosses domains, build on each other's points instead of repeating, and yield to the human when the key perspectives are covered.

Resource Usage

Tested on an M4 MacBook Air (16 GB RAM):

Instances	RAM (idle)	RAM (active chat)
1	~1.5 GB	~2 GB
3	~4.5 GB	~6 GB

Three bots running alongside VS Code, a browser, and Slack — no noticeable slowdown.

What's Next

You now have a three-bot AI team collaborating in Discord — running on your hardware, data fully local, no subscription. From here: add more bots, install skills from ClawHub (13,000+ community), snapshot a well-tuned bot and clone it, or connect additional channels (Telegram, Slack, Lark). The wiki has guides for every provider and channel.

Get Involved

Self-Host OpenClaw on Your Mac in 10 Minutes — One Command, Browser Dashboard

Desmond Wei — Sun, 29 Mar 2026 15:24:58 +0000

A step-by-step guide to self-hosting OpenClaw with Docker on macOS or Linux — no config files, no cloud, managed from a browser dashboard.

You've seen OpenClaw — the open-source AI assistant with 340K+ GitHub stars that connects to 20+ messaging platforms. You want to run it yourself. Your data stays on your machine, you pick your own LLM, no monthly fees.

Then you hit the wall.

Docker setup, port mapping, environment variables, supervisord configs, getting the gateway process to actually start — and if something breaks, you're debugging inside a container with no GUI. Roughly 1 in 5 people who attempt self-hosting never get a working instance. The deployment friction kills the experience before it begins.

ClawFleet eliminates that entire wall. One command installs everything. A browser dashboard replaces the CLI. Ten minutes from now, your first AI agent can be live.

Install

curl -fsSL https://clawfleet.io/install.sh | sh

This single command handles everything:

Installs Docker if you don't have it (Colima on macOS, Docker Engine on Linux)
Downloads the clawfleet CLI
Pulls the pre-built sandbox image (~1.4 GB)
Starts a web dashboard at http://localhost:8080

No YAML files to write. No docker-compose to debug. No manual config.

Set Up Your First Agent (5 minutes)

The installer opens a dashboard in your browser. From there, three steps to a running agent:

1. Register a model — Assets → Models. Paste an API key from OpenAI, Anthropic, Google, or DeepSeek. ClawFleet validates the key before saving — you'll know immediately if something's wrong.

2. Create an instance — Fleet → Create. Each instance is a fully isolated Docker container with its own XFCE desktop, accessible through your browser via noVNC. Your host system is completely untouched.

3. Assign and launch — Pick the model you just registered, assign it to the instance, click "Restart Bot". That's the entire configuration.

Your agent is now live. It's running on your hardware, your data stays local, and there's no subscription. If you close the laptop and reopen it, the agent auto-recovers — no manual restart needed.

Beyond the First Bot

Once your first agent is running, the dashboard unlocks everything else without touching the terminal:

Character system — Define a persona with a bio, backstory, and communication style. Assign it to an instance and the agent takes on that personality across all conversations. Think of it as a job description for an AI employee.
Messaging channels — Connect Telegram, Discord, Slack, or Lark. Your agent responds to real users on real platforms. Each channel is validated before saving so you don't deploy a broken bot.
Skills marketplace — 52 built-in skills (weather, GitHub, coding, web search) plus 13,000+ community skills on ClawHub. Browse and install from the dashboard — one click, no CLI.
Fleet scaling — Need multiple agents? Create more instances, each with a different model, personality, and channel. On a 16GB Mac you can comfortably run 3 bots simultaneously. They're aware of each other and collaborate naturally — an engineer bot will @-mention your marketing bot when a question crosses domains.
Soul Archive — When a bot is performing well, snapshot its entire state (personality, memory, config). Clone it to new instances instantly. No retraining.

Resource Usage

Tested on M4 MacBook Air (16 GB RAM):

Instances	RAM (idle)
1	~1.5 GB
3	~4.5 GB

Lightweight enough to run alongside your daily work.

The Cost

	Managed hosting (2 bots)	ClawFleet (3 bots)
Subscription	~$20/month	$0
LLM API tokens	included	~$25/month
Extra hardware	N/A	$0 (your existing Mac)

You trade a subscription for direct API access — and gain a third bot, full data ownership, and zero vendor lock-in.

Get Started

curl -fsSL https://clawfleet.io/install.sh | sh

Ten minutes from now you'll have a self-hosted AI agent running on your own machine. The wiki has step-by-step guides for every LLM provider and messaging platform if you need them.

If this helped you get started, a reaction helps others find it.

Star ClawFleet on GitHub — it helps others find the project.

Join the Discord — see what others are building with their fleets and get help if you're stuck.

Open source. MIT licensed. Free forever.

DEV Community: Desmond Wei

Your AI Agent’s Prompt Is the Bottleneck, Not the Model

What I Changed (And Why It Worked)

The 4 Things That Actually Matter in Character Design

Pattern 1: Negative Constraints Beat Positive Descriptions

Pattern 2: Collaboration Rules > Individual Brilliance

Pattern 3: Temperature 0.1 for Work, 0.7 for Brainstorming

Pattern 4: The "First 5 Minutes" Test

What I Still Haven't Figured Out

The Uncomfortable Math

The Pattern Behind the Pattern

5 Mistakes to Avoid When Self-Hosting OpenClaw (Learned the Hard Way)

1. Don't Run @latest

2. Each Bot Needs Its Own Container

3. 1.5 GB RAM Per Bot Is Real

4. Character Design Matters More Than Model Choice

5. Save Snapshots Before Every Change

More in This Series

OpenClaw SaaS vs Self-Hosting: Which One Should You Choose in 2026?

What You Get with Managed Hosting

What Self-Hosting Looks Like Now

The Real Comparison

Who Should Use What

Getting Started

More in This Series

Why You Should Pin Your OpenClaw Version — Lessons from v2026.3.31 Breaking Changes

Why Version Pinning Matters

What v2026.3.31 Changes

Should You Upgrade?

The Bigger Picture

More in This Series

How to Run 3 OpenClaw Bots That Collaborate in Discord — Step by Step

Step 0: Install ClawFleet

Step 1: Register a Model

Step 2: Create Three Instances

Step 3: Give Each Bot a Character

Step 4: Connect All Three to Discord

Step 5: Start and Watch Them Collaborate

Resource Usage

What's Next

Get Involved

More in This Series

Self-Host OpenClaw on Your Mac in 10 Minutes — One Command, Browser Dashboard

Install

Set Up Your First Agent (5 minutes)

Beyond the First Bot

Resource Usage

The Cost

Get Started