OpenClaw Setup Guide: 24/7 AI Assistant on VPS or Mac Mini

Disclosure: this guide contains referral links. If you buy through them, I may earn a commission at no extra cost to you.

I’ve been running OpenClaw on a Hetzner VPS since the start of 2026, hooked up to Slack first and Gemini CLI later. Getting it installed is easy. Getting it installed correctly (config file in the right place, pairing locked down, and a scheduler that survives a reboot) is where most guides (including older versions of this one) drift out of date. So here’s the OpenClaw setup guide I wish I’d had when I started: a working install on a cheap VPS or a Mac Mini, a chat channel wired up, and the ops bits that keep it running.

OpenClaw is an open-source, self-hosted AI assistant that lives on a server 24/7 and talks to you through Telegram, WhatsApp, Slack, or Discord. Unlike ChatGPT or Claude where you go to their site, this comes to you. It remembers things across conversations, runs commands and scripts on your box, and pings you when something needs attention. Latest stable as of this update is v2026.10.6 (2026-10-22), with roughly 392k GitHub stars and a weekly-plus release cadence.

If you’re new to AI coding tools, our AI programming beginners guide covers the basics. For running models on your own hardware, see Ollama with Docker Compose.

What is OpenClaw? A 24/7 self-hosted AI assistant

Most AI tools wait for you to ask something. OpenClaw does stuff: it clears your inbox, schedules meetings, researches companies, follows up on tasks, and runs automations on your server.

The architecture is simple. Chat apps feed messages into a gateway that runs on your machine, the gateway calls whatever LLM you picked, and the model can invoke tools and skills on your box.

OpenClaw architecture: chat apps feed the gateway on your VPS or Mac Mini, the gateway calls an LLM provider, and tools and skills run on your server; only the model calls leave your machine

Everything stays on your machine except the AI calls. Your data isn’t living on some company server somewhere. The gateway just runs in the background as a service. Messages come in from Telegram or Slack, get routed to the model, and the model can move files, run scripts, or browse the web through tools.

One more thing that changed this year: OpenClaw now has first-class clients. There’s an iOS App Store app, an Android app on Google Play, a native Windows Hub, a macOS menu-bar app, and a browser Control UI. They pair as nodes to the gateway. Your phone becomes a remote control, not the server. More on that in the install section.

OpenClaw on Mac Mini vs VPS: which one to choose

Kind of a funny situation: the OpenClaw community caused a minor run on Mac Mini M4s. People were buying them just to run this thing. Here’s how to decide which route makes sense for you.

Mac Mini M4 advantages

If you want iMessage, Mac Mini is your only choice. Support is real and documented (via the imsg private API path), but it’s still Mac-only. The M4 chip also handles local models well if you’re trying to avoid API bills. But you need solid home internet and power, with no outages.

For hardware picks, see which Mac mini model you need for OpenClaw.

VPS advantages

For most people, a VPS is the better call:

I’m using a Hetzner CX33 (4 vCPU, 8GB RAM). It handles OpenClaw comfortably with plenty of headroom for other services. Before you commit to any box, benchmark a cloud server so you know what disk and CPU you’re getting.

VPS prices jumped across the board in 2026. If you’re rethinking a rented box, see what changed and when a mini PC wins. If you’re leaning toward owning hardware anyway, a mini PC like the ASUS mini PC pays for itself against a mid-range VPS faster than it used to.

When to choose Mac Mini

• You need iMessage as your primary channel
• You want to run local models (Llama, Mistral) to avoid API costs
• You prefer hardware you physically control
• You already have a Mac Mini sitting around

When to choose VPS

• Telegram, WhatsApp, Slack, or Discord are your primary channels
• You don’t want to deal with home networking
• You need 24/7 uptime without worrying about power outages
• You’re okay paying for API calls

Install OpenClaw on a Hetzner VPS

Takes about 20 minutes start to finish on any Ubuntu 24.04 VPS. I use Hetzner, but these steps work on pretty much any provider. Two supported paths: the one-liner installer (what most solo operators want) and the official Docker VM-runtime path.

The installer provisions Node itself. You do not need NodeSource or a manual Node install.

Create the server

1. Go to Hetzner Cloud Console (via Hetzner Cloud if you’re signing up fresh)
2. Create a new project named openclaw
3. Click Create Server
4. Select:
   • Location: Germany (cheapest) or your nearest region
   • Image: Ubuntu 24.04
   • Type: the entry CX tier (CX23 in the current lineup), around €5.49/mo after the 2026 price hikes. Confirm the exact lineup in the console; it moves.
   • IPv4: Keep enabled
5. Add your SSH key
6. Name it openclaw and create

Wait 30 seconds for the server to boot, then grab the IP address. In the Hetzner cloud firewall, allow TCP 22 only. Nothing else needs to be reachable, and that includes the gateway port.

Install OpenClaw (one-liner path)

SSH into your server:

ssh root@YOUR_SERVER_IP
apt update && apt upgrade -y

Install OpenClaw and run the onboarding wizard:

curl -fsSL https://openclaw.ai/install.sh | bash

The wizard walks you through everything:

• Local vs Remote gateway selection
• Model authentication (API keys or OAuth)
• Channel setup (Telegram, WhatsApp, etc.)
• Background service installation

Use curl -fsSL https://openclaw.ai/install.sh | bash -- --no-onboard if you want the binaries without the wizard, then run openclaw onboard --install-daemon later.

Prefer npm? That path works too (npm 12+):

npm install -g openclaw@latest --allow-scripts=openclaw
openclaw onboard --install-daemon

Install OpenClaw on a VPS with Docker (official path)

This is the path the official Hetzner docs point at now. It isolates state and gives you sane defaults.

apt-get update && apt-get install -y git curl ca-certificates
curl -fsSL https://get.docker.com | sh

Images come from ghcr.io/openclaw/openclaw (Docker Hub mirror at openclaw/openclaw). Tags include latest, extended-stable, and slim / -browser variants (the -browser image bakes in Chromium). State lives in env-configured directories (OPENCLAW_CONFIG_DIR, OPENCLAW_WORKSPACE_DIR, OPENCLAW_AUTH_PROFILE_SECRET_DIR), so you can put them on a persistent volume. The image entrypoint runs Doctor before starting and exits if state can’t be repaired; if the container dies immediately, read the Doctor output in the logs first.

Control UI access through an SSH tunnel: your browser reaches http://127.0.0.1:18789 via ssh -N -L 18789:127.0.0.1:18789; public 0.0.0.0:18789 is never acceptable, and the cloud firewall allows TCP 22 only

# from your laptop, then open http://127.0.0.1:18789/
ssh -N -L 18789:127.0.0.1:18789 root@YOUR_SERVER_IP

If the tunnel fails with “administratively prohibited”, add AllowTcpForwarding local to /etc/ssh/sshd_config on the VPS and restart sshd.

Failure modes on this path:

• Docker build OOMs on a small box. You don’t need to build. Use the pre-built image. ≥6 GB RAM is only required if you build from source; pre-built images run fine on 2-4 GB.
• Container exits right away. Check Doctor output in docker logs. It refuses to start on unrepaired state.
• Tunnel connects but the page won’t load. Make sure the gateway is running inside the container and you’re hitting 127.0.0.1, not the VPS’s public IP.

Verify your install

Don’t declare victory at “the wizard finished”. Run this checklist:

If doctor is clean, security audit has nothing high, and your test DM got a reply, the install is done.

Updates, backups, and rollback

OpenClaw ships weekly or faster. Staying current is not optional hygiene. 75 GitHub security advisories landed on 2026-09-11 alone (30 of them high severity), and the October 2026 Node compromised-certificate issue is why the Node floor exists at all.

openclaw backup        # always before an upgrade
openclaw update        # stable channel
openclaw update --channel beta   # opt-in

Channels are stable, beta, and dev (openclaw update --channel dev). There’s an automatic update check, and the docs keep a rollback-and-recovery runbook. Read it before you need it. Backups are local by default: openclaw backup writes verified state on the box, so copy the output somewhere off-box (S3-compatible storage is the obvious home) or it dies with the VPS.

Control UI and mobile apps

The browser Control UI lives on gateway port 18789. Reach it through the SSH tunnel above, or over Tailscale. If you’re phone-only, /controlui opens it as a Telegram Mini App. New devices that show up need approval: openclaw devices list, then openclaw devices approve <requestId>.

Official clients: iOS App Store app (iOS/iPadOS 26.2+), Android on Google Play (ai.openclaw.app) plus a signed APK on the GitHub releases page, a native Windows Hub app (signed installer, tray, chat, node mode) installed with iwr -useb https://openclaw.ai/install.ps1 | iex, and a macOS menu-bar app.

LLM provider options

OpenClaw works with several AI providers. Current docs recommend the strongest latest-generation model for tool-enabled agents, plus a cheap utilityModel for internal tasks like titles and recaps. Model references look like anthropic/claude-sonnet-4-6 and openai/gpt-5.5 (GPT-5.6 is referenced in the v2026.10.6 notes). Set defaults with openclaw models set, or switch per-session in chat with /model <m> (-s session, -a agent, -g global).

Anthropic (Claude)

This is what I’d recommend for most people. Two ways to connect:

claude setup-token

OpenAI

For GPT-5.5-era models:

1. Go to platform.openai.com
2. Create an API key
3. Enter it during onboarding

If you have a ChatGPT Plus or Codex subscription, OAuth works the same way as Claude.

Google Gemini

Gemini 3 Flash is fast and cheap, and the Gemini CLI OAuth flow is easy:

openclaw configure --section model

The wizard will prompt you to authenticate through Google. (Some older docs show --section models; if the flag is rejected, try the plural spelling.)

Local models (Ollama)

If you want to avoid API costs entirely, OpenClaw works with Ollama. Install it on your server:

curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.2

Then point OpenClaw at the local endpoint in your config. A Mac Mini M4 is the better local-inference host; most VPS boxes will struggle with anything beyond small models. For hardware picks and tuning, see running OpenClaw with local models via Ollama.

Cost comparison

Dollar-per-model tables age badly and provider pricing pages lie by omission, so here are honest bands instead:

The real cost levers, in order of impact:

1. Route cheap internal calls (titles, recaps) to a small model with utilityModel. Set it once in agents.defaults.utilityModel.
2. Use subscription OAuth instead of API keys if you already pay for Claude or ChatGPT. See VibeProxy if you want to route subscription access into other tools.
3. Use local embeddings for memory search: semantic memory works with zero extra API bill (details below).
4. Configure model fallbacks: put a cheap model behind the primary so a rate limit doesn’t stop the assistant.

For model refs themselves, our roundup of the best open source models for OpenClaw covers what runs well. Cheaper frontier-lab alternatives like MiniMax and GLM price a fraction of Anthropic and OpenAI. The nanobot setup guide covers running those providers end to end.

Channel setup

Telegram, WhatsApp, Slack, and Discord are the main four, but OpenClaw now also supports Matrix, Microsoft Teams, Signal, Google Chat, SMS, X/Twitter, IRC, Nostr, Mattermost, Nextcloud Talk, plus regional options like Feishu/LINE/QQ/WeChat/Zalo. The channels docs have per-channel guides for all of them.

Telegram bot setup (easiest)

1. Open Telegram and search for @BotFather
2. Send /newbot
3. Choose a name and username for your bot
4. Copy the bot token BotFather gives you
5. Search for @userinfobot and send any message to get your user ID
6. Feed both to OpenClaw:

openclaw channels add --channel telegram --token <bot-token>

That writes the channel block for you. The shape in ~/.openclaw/openclaw.json looks like this (note the key is botToken, not token):

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "123:abc",
      dmPolicy: "pairing",
      groups: { "*": { requireMention: true } },
    },
  },
}

To verify, send /status to the bot and expect a reply. If nothing comes back, openclaw channels status --probe and openclaw logs --follow will tell you which half is broken.

WhatsApp

WhatsApp is a plugin now:

openclaw plugins install @openclaw/whatsapp
openclaw channels login --channel whatsapp

Scan the QR code from WhatsApp > Settings > Linked Devices. Your personal WhatsApp number becomes the bot’s number. Messages you send to yourself go to OpenClaw. Use --account if you’re running multiple accounts.

Slack

For teams:

1. Create a Slack app at api.slack.com/apps
2. Add Bot Token Scopes: chat:write, app_mentions:read, im:history, im:read, im:write
3. Install to your workspace
4. Copy the Bot User OAuth Token
5. Paste into OpenClaw config

Check Slack’s current manifest/scopes docs for the minimal set before you paste my list; scopes drift. I run OpenClaw in a dedicated Slack channel and mention @openclaw to interact.

Discord

1. Create a Discord application at discord.com/developers
2. Create a bot user and copy the token
3. Invite the bot to your server with appropriate permissions
4. Add the token to OpenClaw config

Memory system

OpenClaw remembers stuff from previous chats. The memory setup has a few parts.

How memory works

Short-term memory is the current conversation context. Long-term memory is facts about you in ~/.openclaw/workspace/MEMORY.md and ~/.openclaw/workspace/USER.md, plus daily notes in memory/YYYY-MM-DD.md (today and yesterday auto-load) and DREAMS.md. Semantic search finds relevant past conversations. Embedding providers now include Local (managed llama.cpp GGUF, ~0.3 GB, no API key), LM Studio, Ollama-compatible endpoints, Bedrock, DeepInfra, Gemini, GitHub Copilot, and Mistral.

That local embedding option matters: semantic memory can run with zero extra API bill. If you’d rather skip embeddings entirely, keyword-only mode is a config flag (memory.search.provider: "none"). There’s also active memory, “dreaming” sweeps, and compaction running in the background.

Making things stick

If OpenClaw keeps forgetting something, just tell it straight up:

“Remember: I prefer meeting invites on Google Calendar, not Outlook.”

It stores this in your memory files. You can also edit them directly:

nano ~/.openclaw/workspace/USER.md

Add your preferences, work context, project details, anything you want it to always know.

Workspace files live in ~/.openclaw/workspace/. For the full list of configuration options, see the AGENTS.default reference.

Config files

Key sections:

Model configuration

{
  agents: {
    defaults: {
      model: {
        primary: "anthropic/claude-sonnet-4-6",
        fallbacks: ["google/gemini-3-flash"],
      },
      utilityModel: "google/gemini-3-flash",  // cheap internal tasks
    },
  },
}

Docs call the fallback key fallbacks. Older snippets showed fallback. If the key is rejected, try that spelling, but fallbacks is the one in the current models FAQ.

Channel settings

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "YOUR_BOT_TOKEN",
      dmPolicy: "pairing",
      groups: { "*": { requireMention: true } },
    },
  },
}

Use the built-in configure commands for the interactive route:

openclaw configure --section channels
openclaw configure --section model

Or edit ~/.openclaw/openclaw.json directly and let hot reload pick it up. openclaw gateway restart is only needed when hot reload tells you it can’t apply a change.

For MCP (Model Context Protocol) integration, see our MCP introduction for beginners.

Skills

Skills are basically reusable workflows OpenClaw can execute. They add capabilities beyond just chatting.

Built-in skills

Some capabilities work immediately:

• File management (organize folders, find files)
• Web search: Brave API key is one option, but you can add free DuckDuckGo web search to OpenClaw without API keys. Start there before paying for a search API.
• Calendar and email (with proper authentication)
• Running scripts and commands

Adding skills

Browse community skills on ClawHub. Install with:

openclaw skills search "calendar"
openclaw skills install @openclaw/demo
openclaw skills update --all
openclaw plugins install clawhub:<package>

The clawhub: prefix is required on plugins up to v2026.10.4. Registry pages show versions, changelogs, and security scan summaries. Read them. The ClawHub supply chain has already produced a real CVE (CVE-2026-25253), so treat skill install like curl | bash, because it is.

Creating custom skills

Skills are defined in ~/.openclaw/workspace/skills/. A skill is basically a prompt template with parameters:

# Research Skill

Research {topic} and provide:
- 3 key findings
- Relevant sources
- Next steps

You can also ask OpenClaw to create skills for you:

“Create a skill that checks my GitHub repos for new issues every morning.”

Custom skill folders

Load skills from a custom location:

{
  "skills": {
    "paths": ["~/.openclaw/workspace/skills", "~/my-custom-skills"]
  }
}

Coding tool skills (Claude Code, Codex, Gemini CLI)

One of OpenClaw’s most useful skills lets it drive AI coding tools directly. With Claude Code, OpenAI Codex CLI, or Gemini CLI installed on your server, you can message OpenClaw from your phone:

“Use Claude Code to create a FastAPI app with user authentication and deploy it to my server.”

OpenClaw launches the coding CLI, passes your requirements as prompts, monitors the session, and reports back. Make sure the CLI is installed and authenticated:

claude --version && claude login   # Claude Code
gemini --version                   # Gemini CLI
codex --version                    # OpenAI Codex

Then tell OpenClaw what’s available (“I have Claude Code installed. Use it when I ask you to build something”). It stores that in memory.

One hygiene note: exec approvals have had real advisories (the 2026-09-11 batch included approvals outliving their working directory). Don’t leave blanket exec approvals sitting around; review them the same way you’d review sudo rules. If you juggle all three CLIs, Agent Router gives you unified access from one endpoint.

For more on these tools, see our best AI coding tools comparison.

OpenClaw automations: scheduled jobs and reminders

This is where it stops being a chatbot and starts automating things.

Reminders and one-shot jobs

Simple reminders work out of the box:

“Remind me to check server logs every Monday at 9am.”

“In 3 hours, remind me to review the pull request.”

When you need precision, skip the natural language and use the CLI:

openclaw automations create "2027-02-01T16:00:00Z" --name "Reminder" --session main \
  --system-event "Reminder: check the automations docs draft" --wake now --delete-after-run
openclaw automations list
openclaw automations runs <job-id>

--delete-after-run keeps one-shot jobs from piling up. Run history lives in automations runs <job-id>. Check it when a reminder didn’t fire.

Recurring schedules

Cron-style schedules still work in plain English:

“Run a disk space check every day at midnight.”

“Every 6 hours, check if my website is responding and alert me if it’s down.”

These create automation jobs too. openclaw cron list works as an alias for openclaw automations list. Use the /loop chat shortcut for standing orders. Beyond the clock, jobs can also trigger from webhooks and Gmail PubSub. See the automation docs for those.

Proactive monitoring

Unlike ChatGPT or Claude web, OpenClaw messages you first:

“Monitor my server’s CPU usage. If it goes above 80% for more than 5 minutes, message me.”

“Watch my inbox for emails from [client]. When one arrives, summarize it and send to me immediately.”

Express these as recurring automation jobs or /loop standing orders rather than the old heartbeat monitors.

Example: daily standup assistant

“Every weekday at 8:30am:

1. Check my calendar for today’s meetings
2. Scan my email for urgent items
3. Look at my GitHub notifications
4. Send me a single message summarizing all of this”

One Telegram message covers what needs attention before you open your laptop.

Running Agno and Python scripts with OpenClaw

Agno is a Python framework for building AI agents. Pair it with uv for fast package management and you can build scripts that OpenClaw runs for you. This is OS-level integration (OpenClaw shells out to your script), so it works regardless of which LLM you use.

OpenClaw handles the messaging side. Agno handles the complex AI work: multi-agent setups, RAG pipelines, tool use. You message OpenClaw on Telegram, it runs your Agno script, Agno does the research or analysis, and the results come back through OpenClaw.

Install uv on your server:

curl -LsSf https://astral.sh/uv/install.sh | sh

Create a scripts directory:

mkdir -p ~/openclaw-scripts
cd ~/openclaw-scripts
uv init
uv add agno openai duckduckgo-search

Example: research agent script

#!/usr/bin/env python3
# ~/openclaw-scripts/research_agent.py
# /// script
# requires-python = ">=3.11"
# dependencies = ["agno", "openai", "duckduckgo-search"]
# ///

import sys
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

def research(topic: str) -> str:
    agent = Agent(
        model=OpenAIChat(id="gpt-4o"),
        tools=[DuckDuckGoTools()],
        instructions=[
            "You are a research assistant.",
            "Search the web for current information.",
            "Provide concise, factual summaries.",
        ],
        markdown=True,
    )

    response = agent.run(f"Research this topic and provide key findings: {topic}")
    return response.content

if __name__ == "__main__":
    topic = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "AI agents"
    print(research(topic))

chmod +x ~/openclaw-scripts/research_agent.py

Tell OpenClaw about it:

“I have a Python script at ~/openclaw-scripts/research_agent.py that does web research. When I ask you to research something complex, run it with uv like this: uv run ~/openclaw-scripts/research_agent.py [topic]”

Then message “Research the latest developments in autonomous AI agents” and it runs the script, which spawns its own agent, and returns the results.

Scripts you might build:

The pattern is always: write the script, store it in your scripts directory, tell OpenClaw how to run it, trigger via message or schedule. For multi-agent setups see the Agno research squad guide, and for tool integrations see Agno with MCP tools.

Commands reference

Full index lives at docs.openclaw.ai/cli. The ones you’ll use:

Chat commands, sent in your messaging app:

Practical uses

Stuff that works in practice:

Morning briefings

“Every weekday at 7am, check my calendar and email, then send me a summary of what needs attention today.”

Research tasks

“Research the top 5 competitors to [company]. Give me a one-page summary with strengths and weaknesses.”

File management

“Organize my Downloads folder. Put PDFs in Documents/PDFs, images in Pictures, and delete anything older than 30 days.”

Code assistance

“Review the latest commit in my repo and flag any security concerns.”

Or go further and have your AI assistant deploy Docker apps with a single message.

Reminders and follow-ups

“Remind me to follow up with [person] about [topic] in 3 days.”

What requires more setup

These work but need custom skills or integrations:

• Full email management with auto-responses
• Trading alerts and market monitoring
• Multi-platform social media posting
• CRM integration

See our best AI coding tools article for tools that handle specific developer workflows.

Troubleshooting

Bot not responding

openclaw status --all
openclaw logs --follow

Usually one of these:

• Gateway crashed or isn’t running
• API key expired or got rotated
• Channel token is wrong or expired
• Node too old: openclaw update refuses to run below 24.22.1/26.12.1

Pairing code required (or expired)

Default security requires approving new senders:

openclaw pairing list telegram
openclaw pairing approve telegram <code>

Codes expire after 1 hour. If yours timed out, DM the bot again for a fresh one.

Context too large

Long conversations hit token limits:

/compact

Or start fresh:

/new

Docker container exits at startup

Read the Doctor output; docker logs <container> shows why. The entrypoint runs Doctor before the gateway and exits if state can’t be repaired. Common causes: bad permissions on the config/workspace volume, or a half-migrated openclaw.json.

SSH tunnel says “administratively prohibited”

Add AllowTcpForwarding local to /etc/ssh/sshd_config on the VPS, systemctl restart ssh, and reconnect the tunnel. And no, opening 18789 publicly is not the workaround.

OOM on a small VPS

If you tried to build the Docker image on a 2 GB box, don’t. Use the pre-built ghcr.io/openclaw/openclaw image. For the bare install, 2 GB is workable, 4 GB is comfortable.

Port 18789 already in use

Something else grabbed the Control UI port. ss -tlnp | grep 18789 shows who. Stop it or move the gateway port in config.

SSH asks for a password when you have a key

ssh -i ~/.ssh/id_ed25519 root@YOUR_SERVER_IP

Need to redo setup

openclaw reset
openclaw onboard --install-daemon

OpenClaw security considerations

OpenClaw has shell access to your server. That’s the feature and the risk. Start with the canonical check:

openclaw security audit

It’s a catalog of check IDs with severities and auto-fixes. Run it after every config change and after every update. Then work through the rest.

Gateway exposure. Host installs bind loopback by default. Never open TCP 18789 publicly. Use the SSH tunnel or Tailscale (see the Docker install section above). Your cloud firewall should allow TCP 22 and nothing else.

Pairing defaults. The default DM policy is pairing: unknown senders get a code instead of bot access. Don’t disable it unless you understand the implications. Group access stays behind requireMention: true.

One trust boundary per gateway. OpenClaw is not a multi-tenant boundary. Users who shouldn’t see each other’s data, or who might actively attack the agent, get separate gateways: separate OS users, separate hosts. Adding everyone to one allowFrom list is fine for your household, not for hostile tenants.

Stay current. 75 GitHub security advisories shipped on 2026-09-11 alone (30 high severity, including exec approvals outliving their working directory, WhatsApp login tool cross-turn reach, Matrix user-ID conflation, and config revision hashes exposing password verifiers). ClawHub had CVE-2026-25253. The October 2026 Node compromised-certificate incident is why the Node floor exists. Release cadence is weekly-plus, so openclaw update is part of operations now, not an occasional chore.

Ops hygiene:

If something did get abused, treat it like any other compromised service: stop the gateway first, then rotate credentials, then read logs. Don’t debug while it’s still running.

What’s next

Once you have OpenClaw running:

1. Customize the personality in ~/.openclaw/workspace/SOUL.md to change how it communicates
2. Fill in ~/.openclaw/workspace/USER.md with your work and preferences
3. Check the AGENTS.default reference for the full list of settings
4. Browse ClawHub for useful skills and read the security scan summaries before installing
5. Add web search: free DuckDuckGo web search without API keys is the right default. Use Brave or a paid agent search API like TinyFish only if you need more
6. Connect more tools: GitHub, Google Drive, calendar integrations
7. Install the mobile apps and pair them as nodes (see the Control UI section above)
8. Keep it updated with monthly openclaw backup + openclaw update at minimum (see Updates, backups, and rollback)

The official docs have detailed setup guides for specific integrations.

OpenClaw isn’t magic. It’s a tool for running AI assistants that fit into how you already work. Setup is a bit of work, no doubt. But having an assistant that’s available 24/7 and does the work instead of just chatting about it has been worth the hassle for me.

Before exposing your instance to the internet or installing skills from ClawHub, read the OpenClaw security guide covering CVE-2026-25253 and the 40+ fixes shipped in recent releases.

If you want to explore what else is out there, check out OpenClaw alternatives worth trying: NanoClaw, nanobot, memU, and bitdoze-bot. For a detailed walkthrough of nanobot with MiniMax M2.5 and GLM-5, see our nanobot setup guide. If you’d rather run models locally instead of paying for APIs, the OpenClaw with Ollama guide covers hardware and configuration. Once OpenClaw is running, a proper UI helps: the best OpenClaw dashboards and command centers covers nine community-built options. For the wider map of AI tools on GitHub (Hermes, Pi, OpenCode, memory, gateways), see top AI GitHub repos. And if you want a Grok Bot style app instead, with a roster of bots that each get their own computer, see our open source Grok Bot alternatives.