OpenClaw: Running Your Own AI Agent the Right Way

At the end of 2025, an open-source project showed up on GitHub and started collecting stars at a pace nobody expected. It went through three name changes, survived a cryptocurrency scam that exploited its brand, weathered real security concerns from the community, and dealt with a trademark dispute with Anthropic. The project settled on OpenClaw and kept shipping.

Behind the noise, something worth paying attention to was taking shape.

I've been running OpenClaw for weeks now. Not kicking the tires — actually relying on it. Publishing blog posts, managing infrastructure, automating workflows, building tools. This is what I found.

What OpenClaw Actually Is

Strip away the hype and here's what you get: an open-source gateway that sits between AI models and the real world. It gives an AI agent a computer to live on, hands to work with, and a messaging channel to talk through.

You install it on a machine. Connect a chat app — Telegram, WhatsApp, Discord, iMessage. Plug in an AI model. Now you've got an agent you can message from your phone that can execute shell commands, write and edit files, browse the web, call APIs, and run background tasks on a schedule.

The key thing people miss: OpenClaw is not an AI model. It's the nervous system. You bring the brain.

Choosing a Brain

Your options, honestly:

Anthropic Claude API — The best experience for tool use by a meaningful margin. When you ask it to set up a web server, it doesn't explain how — it writes the config, starts the service, tests it, and reports back. Pay-per-use, typically $3–15/month depending on how much you use it.

OpenRouter — One API key, dozens of models. Good if you want flexibility or want to compare models without managing multiple accounts. Pay-per-use pricing.

OpenAI API — GPT-4o is solid. Not quite Claude's level for multi-step tool orchestration, but capable. Pay-per-use.

Google Gemini API — Has a free tier. Worth testing if cost is the primary concern.

Ollama (local models) — Free. Runs Llama 3, Mistral, Qwen on your own hardware. No data leaves your machine. The honest trade-off: local models are noticeably weaker at complex tool use. Simple tasks work. Multi-step workflows often break down. Start here if you want to experiment, but know the ceiling is lower.

One thing that trips people up: ChatGPT Plus ($20/month) and Claude Pro ($20/month) are web app subscriptions. They don't give you API access. OpenClaw needs API keys, which are separate products billed per-use. Different thing entirely.

What a Day With It Looks Like

Theory is cheap. Here's what actually happens.

Automated publishing: A cron job fires every morning. The AI scans tech news sources, picks the stories worth reading, writes summaries, and publishes a digest to my blog. I wake up and it's done. Another cron runs three times a week for tool spotlight posts. No human in the loop after initial setup.

Building things through chat:

Me: build an interactive regex playground for the blog

AI: I'll create a page with real-time pattern matching, 
    common patterns library, and a cheat sheet. Few minutes.

[12 minutes later]

AI: Live at /regex/. Tested mobile and desktop. 
    Want it in the nav?

Not hypothetical. That page exists on our site right now. Built entirely through a Telegram conversation.

Infrastructure management: Docker container crashes at 3 AM. The AI's heartbeat check catches it, reads the logs, identifies the issue, restarts it, and sends me a summary in the morning. I never knew there was a problem.

The mundane stuff: "Remind me Thursday to check the PR." "What was that config value we set last week?" "Update the blog theme and bump the version." Small things that add up. Having something that remembers context and can act on it saves more time than the flashy tasks.

The Memory System

This is what separates OpenClaw from "chatbot with shell access."

Most AI conversations reset every time. OpenClaw maintains workspace files that persist:

• SOUL.md — The AI's personality and communication style. You define this.
• USER.md — Who you are. Timezone, preferences, projects, how you work.
• MEMORY.md — Long-term memory. The AI curates this — decisions, lessons, context worth keeping.
• Daily logs — memory/YYYY-MM-DD.md files with raw notes from each day.

Every session, the AI reads these first. When you say "check on that thing from yesterday," it knows what you mean. When you reference a project from two weeks ago, it has context.

It's not magic — it's just files. But the effect is genuine continuity that changes how you interact with it.

Heartbeats and Cron Jobs

Two features that make this an agent instead of a chatbot:

Heartbeats: The AI periodically wakes up, checks a task file, and handles whatever's listed — monitoring, email checks, calendar reminders. Reaches out if something needs attention. Stays quiet otherwise.

Cron jobs: Scheduled tasks with exact timing. Daily digest at 6 AM. Weekly security audit on Monday. Reminder next Thursday. These run in isolated sessions — the AI works independently and delivers results to your chat.

Your AI works while you don't. That's the point.

Installing and Running It

Requirements: Node.js 22+, a machine that stays on, an AI model API key.

First: create a dedicated user. Don't run OpenClaw as root. Create a service account with its own home directory:

sudo useradd -m -s /bin/bash openclaw
sudo su - openclaw

Everything that follows runs as this user. Your config, workspace, credentials, and session logs all live under ~openclaw/.openclaw/. Isolated from the rest of your system.

npm install -g openclaw
openclaw setup

The setup wizard walks you through config, API keys, and workspace initialization. Once done, install it as a system service:

openclaw gateway install

On Linux, this creates a systemd service that starts automatically on boot. On macOS, it uses launchd. The gateway runs in the background — no terminal needed.

openclaw gateway start      # start the service
openclaw gateway stop       # stop it  
openclaw gateway restart    # restart after config changes
openclaw gateway status     # check if it's running

Verify everything is healthy:

openclaw status

This shows you everything at a glance — gateway health, connected channels, active sessions, Tailscale status, available updates. If something's wrong, you'll see it here.

Other commands you'll use daily:

openclaw doctor              # health checks + quick fixes
openclaw security audit      # check your security posture
openclaw security audit --fix # auto-fix common issues
openclaw logs                # tail the gateway logs
openclaw gateway restart     # restart after config changes
openclaw gateway usage-cost  # see what you're spending on API calls

Connect a channel:

• Telegram: Create a bot via @BotFather, add the token to your config, message your bot — it'll send a pairing code to verify it's you
• WhatsApp: openclaw channels login — scan the QR code
• Discord: Create a bot application, add the token to config

First conversation: Once a channel is connected and paired, message your bot. It'll introduce itself and walk you through setting up the workspace files (SOUL.md, USER.md). Tell it who you are, how you work, and what you want it to do. This shapes everything after.

Config lives at ~/.openclaw/openclaw.json. Workspace at ~/.openclaw/workspace/. The full CLI reference covers everything, but the commands above are what you'll actually use.

Security: Read This Before You Do Anything

You're giving an AI shell access. Take this seriously.

Use a dedicated machine. Not your daily laptop. Not your production server. A $5/month VPS, a Raspberry Pi, a spare mini PC. If the AI makes a mistake — and it will — you want the damage contained to something you can wipe.

Lock down who can talk to it. The real risk isn't sophisticated attacks. It's someone messaging your bot and the bot doing what they ask.

{
  "channels": {
    "telegram": {
      "allowFrom": ["your_telegram_user_id"]
    }
  }
}

In group chats, require mentions: "groups": { "*": { "requireMention": true } }

Run the built-in audit:

openclaw security audit --deep
openclaw security audit --fix

Catches open policies, exposed ports, permission issues, common misconfigurations.

Set gateway auth:

{
  "gateway": {
    "auth": {
      "mode": "password", 
      "password": "something-long-and-random"
    }
  }
}

Use Tailscale for remote access instead of exposing ports to the internet. Free for personal use.

File permissions: chmod 700 ~/.openclaw && chmod 600 ~/.openclaw/openclaw.json

Session transcripts contain your full conversation history. Treat disk access as the trust boundary.

The philosophy: Identity first (who can talk), scope next (what it can do), model last (assume the model can be tricked — limit the blast radius).

The Costs

For comparison: ChatGPT Plus and Claude Pro are $20/month each — and they can't execute commands, publish your blog, or manage your servers.

The Limitations

• You need terminal comfort. npm, JSON configs, SSH. If the command line is unfamiliar, this isn't ready for you yet.
• Local models have a real ceiling. Simple queries work. Complex multi-step tool use breaks down. The free path has limits.
• It makes mistakes. Shell access means real consequences. Start with limited permissions. Build trust gradually.
• The project is young. Moving fast, breaking things between updates. The community is active but small.
• Cloud models see your messages. Unless you run local, your conversations go to Anthropic/OpenAI for processing. Self-hosted gateway doesn't mean fully private.

The Verdict

I've used a lot of tools that promise to make AI useful. Most of them add a layer between you and the model and call it a product.

OpenClaw does something different. It removes the layer between the AI and your actual systems. The AI stops being an advisor and starts being a worker.

It's not for everyone. It's not plug-and-play. The security responsibility is real. But if you're comfortable in a terminal and want an AI that does things instead of just talking about them — this is the most capable implementation of that idea I've found.

OpenClaw · Documentation · GitHub · Community Discord

Compiled by AI. Proofread by caffeine. ☕