We've deployed OpenClaw agents for our own operations and for several clients at this point. The process has gotten predictable. What used to take a full afternoon now takes about 45 minutes if you know what you're doing. We thought we'd share our actual setup process, from picking hardware to connecting channels to making the agent useful.
Pick your hardware
You have two real options: a Mac Mini or a VPS.
Mac Mini is what we run internally. An M4 base model ($599) sits on your desk, stays on 24/7, and runs the agent locally. You plug it in, connect it to WiFi or ethernet, and (mostly) forget about it. No monthly hosting fees beyond your internet connection and the electricity.
The downside is you need physical access for maintenance, and if your office loses power or internet, your agent goes down with it. In practice this hasn't been an issue for us, but it's worth knowing.
A VPS (DigitalOcean is what we'd recommend) is the other path. You can spin up a "Droplet", which is a virtual computer that you can connect to remotely via SSH. It's easier to manage remotely, you get better uptime guarantees, and you can scale the hardware without buying a new box. Monthly cost runs $10-40 depending on the provider and specs. Note you'll needat least 2GB of Memory.
Our recommendation: Mac Mini if the agent is for one person or a small team and you want everything local (or if you just have a computer to spare). VPS if you're deploying for a distributed team or want hands-off infrastructure.
Set up the prerequisites
If you're starting from a fresh Mac (new Mac Mini out of the box, or a wiped machine), you need to install a few things before OpenClaw. This takes about 10 minutes.
Homebrew is the package manager for macOS. Open Terminal and run:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Follow the prompts. Once it's done, it'll tell you to add Homebrew to your PATH. Run the commands it gives you (they look like echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile), then restart your terminal or run source ~/.zprofile.
Node.js is the runtime OpenClaw runs on. Install it through Homebrew:
brew install node
Verify it worked with node -v. You want version 22 or higher.
pnpm is the package manager OpenClaw uses. Install it after Node:
npm install -g pnpm
Claude CLI is needed if you're using Anthropic as your model provider (which we recommend). It handles the OAuth token that OpenClaw uses to authenticate with Claude:
npm install -g @anthropic-ai/claude-code
claude
Running claude for the first time walks you through authenticating with your Anthropic account. This generates the OAuth token that OpenClaw picks up automatically.
On a VPS running Ubuntu, you'd skip Homebrew and install Node through apt or nvm instead, but the rest of the process is the same.
Install OpenClaw
With the prerequisites in place, one command:
curl -fsSL https://openclaw.ai/install.sh | bash
That pulls down the CLI and launches the onboarding wizard. The wizard walks you through picking a model provider, setting up your first channel, and configuring the agent's identity.
On a VPS like DigitalOcean, OpenClaw provides a few steps here to get you started. You'll want to use your terminal on your computer to SSH into your remote server and run the commands there!
Choose your model provider
The onboarding wizard asks which AI model you want to power the agent. Two main options here.
Anthropic (Claude) is what we use. Claude Opus for the main agent, Claude Sonnet for lighter tasks and sub-agents. The reasoning quality is strong, it follows instructions well, and it handles long context without falling apart. You'll need an Anthropic API key, which means setting up an account at console.anthropic.com and adding a credit card. Costs vary by usage but expect $50-200/month for a moderately active agent.
OpenAI (GPT) works too. Some clients prefer it because they already have OpenAI API access through their company. The setup is identical from OpenClaw's side. You paste in your API key during onboarding and pick which model you want.
You can also use Google's Gemini, Groq, or local models through Ollama. We've stuck with Anthropic for production agents because it's been the most reliable for agentic work, but the architecture is model-agnostic. You can swap providers later without rebuilding anything.
Connect your channels
This is where the agent becomes useful. An agent that only lives in a terminal isn't much help to anyone. You want it reachable through the tools your team already uses.
Slack is the most common setup for companies. You create a Slack app in your workspace, give it the right permissions (chat:write, channels:history, users:read, etc.), and paste the bot token and app token into OpenClaw's config. The agent shows up as a bot user in your Slack workspace. People can DM it, mention it in channels, and it responds in threads. This is what we use!
Telegram is popular for smaller teams or founders who want a personal agent on their phone. You create a bot through Telegram's BotFather, grab the token, and add it to the config. Takes about 5 minutes. The agent then lives in a Telegram chat. You text it like you'd text a person. We've set this up for clients who wanted something that felt more like a personal assistant than a workplace tool.
WhatsApp is the trickiest to connect but also the most natural for people who already live in WhatsApp. OpenClaw uses the Baileys library to link to WhatsApp Web. You scan a QR code, and the agent can read and respond to messages. For business WhatsApp accounts, full read-write works well. For personal accounts, you might want to start with read-only mode until you're comfortable with how the agent responds.
You can connect multiple channels simultaneously. An agent on Slack and Telegram is a common pattern. Same agent, same memory, same personality, just reachable from different surfaces.
Configure the agent's identity
OpenClaw uses a few markdown files in a workspace directory to define who the agent is and how it behaves.
SOUL.md is the big one. This is the agent's personality, communication style, boundaries, and rules. Ours tells our agent to be direct, skip filler language, have opinions, and never make stuff up. It also sets security rules (don't leak private data in group chats, ask before sending external communications, etc.). Think of it as a job description combined with a behavioral contract.
USER.md describes who the agent is helping. Names, roles, preferences, anything the agent should know about the people it works with.
AGENTS.md defines operational rules. How the agent handles memory, when it should stay quiet in group chats, what it's allowed to do without asking.
These files take maybe 20 minutes to write for a basic setup. For more complex deployments (multiple users, specific compliance requirements, detailed workflow rules), plan for an hour or two of thoughtful configuration. The quality of these files directly determines how useful the agent is. A vague SOUL.md produces a vague agent.
Add skills
This is where OpenClaw gets interesting. Skills are self-contained instruction sets that teach the agent how to use specific tools or follow specific workflows.
The agent ships with a handful of built-in skills (web search, GitHub operations, weather, image generation, etc.). But the real power comes from adding your own.
A skill is just a folder with a SKILL.md file inside it. The SKILL.md contains YAML frontmatter (name, description, any requirements) and then natural language instructions telling the agent how to use whatever tool the skill is about.
Drop a skill folder into your workspace's skills/ directory and the agent picks it up automatically. No restart required.
ClawHub (clawhub.com) is the public registry for community-built skills. Browse it, find one you want, install it:
clawhub install <skill-slug>
That downloads the skill into your workspace and it's immediately available.
Custom skills are where companies get the most value. We've built skills for our team that handle podcast marketing pipelines, case study generation from project management data, PDF editing, and client-specific workflows. The pattern is always the same: figure out a repeatable process, write clear instructions for it in a SKILL.md, and let the agent execute it.
For example, we have a skill that takes a podcast transcript and generates 40+ pieces of marketing content from it (blog posts, LinkedIn posts, Twitter threads, Instagram captions). Another one pulls sprint data from Linear and builds branded review decks in Google Slides. These save hours of manual work every week.
Writing a skill doesn't require any programming. It's English instructions in a markdown file. If you can write a good SOP for a human employee, you can write a skill for an OpenClaw agent.
The stuff people forget
A few things that trip people up on first deployments:
Memory matters. OpenClaw agents wake up fresh every session. They persist memory through markdown files in a memory/ directory. Set up the memory structure early (daily logs, people files, project files, decision logs) and the agent gets smarter over time. Skip this and every conversation starts from zero.
Heartbeats keep it alive. OpenClaw can poll the agent on a schedule (every 30 minutes, every hour, whatever). The agent checks for new emails, upcoming calendar events, unread messages, and proactively reaches out if something needs attention. Without heartbeats configured, the agent only responds when spoken to. With them, it becomes genuinely proactive.
Start narrow. The temptation is to connect everything on day one. Don't. Start with one channel, one or two skills, and a basic SOUL.md. Let the team use it for a week. See what works, what's annoying, what's missing. Then expand. Every deployment we've done that tried to boil the ocean on day one ended up needing a reset.
What it looks like in practice
Our agent runs on a Mac Mini in the office. It's connected to Slack, has read access to email and calendar, and has about 15 custom skills. It handles meeting note processing, sprint review deck generation, blog post drafting, client research, and a bunch of smaller automations.
Total setup time for the initial deployment was about an hour. We've spent maybe another 10-15 hours over the past month adding skills, tuning the personality, and building out memory structures. That investment compounds. The agent is measurably more useful now than it was in week one because it has context, it has skills, and it knows how we work.
The barrier to entry is lower than you would think! Have any questions? Contact us and we'll help you get started.