I've been building AI agents for two years. CrewAI, LangGraph, AutoGen — I've shipped production systems on all of them. When OpenClaw started appearing everywhere in my feed, my default reaction was skepticism. Another hyped framework. Another weekend project that'd be abandoned by Q2.
I was wrong.
After running OpenClaw for a week straight — connecting it to Telegram, pointing it at my local filesystem, and watching it handle real tasks I'd normally do myself — I understand why Jensen Huang called it "probably the single most important release of software, probably ever." That's a bold claim. But the architecture underneath OpenClaw is genuinely different from everything I'd built before.
This guide is the setup walkthrough I wish I'd had. It covers what OpenClaw actually is (and what it isn't), a clean installation from scratch, the security configuration steps that most tutorials skip entirely, and the real use cases where it earns its place in your stack.
If you're here for the quick install and you'll handle the rest yourself — jump straight to Step 2. If you want to understand what you're actually running before you give an AI agent shell access to your machine, read from the top.
What OpenClaw Actually Is
OpenClaw isn't a chatbot wrapper. It's an agent runtime — a local daemon that runs on your machine, connects to an LLM of your choice, and bridges that model to real-world tools: your filesystem, your browser, your messaging apps, the web, and external APIs.
The key difference from something like Claude in a browser: OpenClaw has hands.
Here's the architecture at a glance:
You talk to it through whatever messaging app you already use. It routes through the local Gateway, which decides what tools to call, what to remember, and what to actually execute on your behalf.
What makes this different from a chat interface:
-
Persistent memory across sessions — it writes a daily diary and maintains a running to-do list
-
A "soul" file — a personality/instruction file that defines how the agent behaves, what it knows about you, and what it's allowed to do
-
A Heartbeat scheduler — the agent can run proactively on a schedule, not just when you message it
-
Skills from ClawHub — a community registry of pre-built capabilities (browser automation, email triage, lead gen, etc.)
Now that you know what you're working with — let's install it.
Prerequisites
Before you touch the install command:
Requirement Minimum Recommended OS macOS, Windows, Linux macOS or Ubuntu 24.04 LTS Node.js v22.16+ Latest LTS RAM 8GB (expect sluggishness) 16GB+ Disk 20GB free 100GB (logs and memory grow) LLM API key OpenAI or Anthropic Anthropic Claude (best results)
For model costs: Claude Sonnet typically runs $0.50–$2.00 per 100 tasks depending on context. If you want zero API cost, you can point OpenClaw at a local Ollama instance — but expect noticeably slower reasoning on complex tasks.
Get your Anthropic API key from console.anthropic.com before starting. Set a spending limit before you do anything else.
Step 1: Install the OpenClaw Daemon
One-line install that works on macOS, Linux, and WSL2 on Windows:
curl -fsSL | bash
```This pulls down the Node.js dependencies and the CLI. Once it completes, verify:
openclaw --version
Expected: openclaw/2026.x.x node/v22.x.x
Alternatively
npm install -g @openclaw/cli
openclaw onboard --install-daemon
This- **LLM provider selection** — choose Anthropic (Claude) for best tool-use reliability - **API key entry** — gets stored securely in `~/.openclaw/credentials/` - **Messaging channel setup** — at minimum, connect one channel (start with Telegram) - **Daemon installation** — registers OpenClaw as a background service that starts on boot Once complete, the web dashboard is available at:
This## Step 3: Connect Your First Messaging Channel I recommend starting with **Telegram** — it's the easiest to configure and has no platform restrictions on bot behavior. **Create a Telegram bot:** - Open Telegram and search for `@BotFather` - Run `/newbot` and follow the prompts - Copy the API token it gives you **Connect it to OpenClaw:**
openclaw channels add telegram
Paste your bot token when prompted
Verify
openclaw channels list
telegram ✓ connected last_msg: never
```Now open Telegram, find your new bot, and send it a message: hello. You should get a response from your OpenClaw agent within a few seconds.
If you want to connect iMessage (macOS only), WhatsApp, Discord, or Slack — the dashboard walks you through each one under Settings → Channels.
Step 4: Configure Your Agent's Soul
This is the step most guides skip, and it's the most important one for making the agent actually useful.
Your agent's "soul" is a Markdown file at:
~/.openclaw/soul.md
```Open it:
nano ~/.openclaw/soul.md
Here
Identity
You are my personal AI assistant and development partner. You are precise, direct, and never verbose. If you're uncertain about an action, ask before executing.
About Me
- I'm a developer focused on AI agents and agentic systems
- My projects include [LaunchSuite] and [SprintLabs]
- My primary stack: Python, Next.js, FastAPI, Supabase
- Timezone: IST (UTC+5:30)
Working Style
- Brief responses unless I explicitly ask for detail
- Always confirm before executing destructive actions (delete, overwrite, deploy)
- When summarizing code or logs, highlight the most important line first
What I DON'T want
- No motivational openers
- Don't summarize what you just did unless there's something notable
- Never store passwords or secrets in memory files
## Step 5: Install Your First Skills
Skills are how OpenClaw interacts with the outside world. Browse available skills:
openclaw skills search web
Returns: web-browser, web-scraper, link-preview...
Install
openclaw skills install web-browser openclaw skills install file-manager openclaw skills install summarizer
Verify
openclaw skills list
web-browser ✓ active permissions: browser
file-manager ✓ active permissions: fs.read, fs.write
summarizer ✓ active permissions: none
```Before installing any skill from ClawHub, check the permissions field in its metadata. A summarizer skill should never request shell.execute. A weather skill should never request fs.read_root. If a skill's permissions don't match its stated purpose, don't install it.
This matters because in early 2026, the ClawHub registry suffered a supply chain attack (dubbed "ClawHavoc") where a significant portion of community skills contained malicious payloads targeting credentials. Always verify.
Step 6: Security Configuration (Don't Skip This)
This is the section that most setup guides either bury in a footnote or skip entirely. I'm putting it here because skipping it is how you end up with an always-on AI agent with shell access to your machine exposed to the internet.
OpenClaw is powerful precisely because it can execute real actions. That's also why it requires careful configuration.
6a. Create a dedicated OS user for OpenClaw:
# macOS / Linux
sudo useradd -m -s /bin/bash ai-agent
# Give it access only to its own home dir and your project folders
```Don't run OpenClaw as your primary user. If an agent action goes wrong or a skill is compromised, you want the blast radius contained.
**6b. Whitelist only your own user ID in Telegram:**
In `~/.openclaw/config.json`:
{ "channels": { "telegram": { "allowed_user_ids": ["YOUR_TELEGRAM_USER_ID"] } } }
```Get your Telegram user ID by messaging @userinfobot. Without this, anyone who finds your bot can talk to your agent.
6c. Set API spending limits:
In your Anthropic console, set a hard monthly limit before you start. I use $10/day as a ceiling for development. It's easy to forget a Heartbeat task is looping through expensive context.
6d. Run the health check:
openclaw doctor
```This surfaces misconfigurations — exposed DM policies, overpermissioned skills, missing rate limits. Fix everything it flags before moving on.
**6e. For production or always-on deployment — use NemoClaw:**
Nvidia released NemoClaw on March 16, 2026, specifically as an enterprise security layer for OpenClaw. Its headline feature is OpenShell sandboxing — every agent action runs in an isolated container with whitelisted filesystem access and filtered network requests. If you're running OpenClaw on a server or a shared machine, NemoClaw isn't optional.
npm install -g @nemoclaw/cli nemoclaw init --wrap-openclaw
After a week of running OpenClaw against real workflows, here's where it actually earns its place:
**Morning briefing via Telegram** — every morning at 7am, the Heartbeat scheduler fires and sends me: a summary of unread GitHub notifications, a status check on my deployed services, and today's top 3 items from my to-do list. Zero manual effort.
**Dev research queries from my phone** — when I'm away from my laptop and need to look something up (package compatibility, API endpoint format, a quick code snippet), I just message the bot. It has context about my stack from [soul.md](http://soul.md), so the answers are immediately relevant.
**Log triage** — I pointed the file-manager skill at my `/logs` directory (read-only mount). When a service throws an error, I can paste the relevant log ID into Telegram and get a parsed summary with the likely cause. Faster than opening the log file myself.
**Where I didn't use it** — I have not given it write access to my production database or deployment pipelines. Not yet. Start with read-only skills, verify behavior for a few days, then expand permissions deliberately. The agent that triage your logs is very different from the agent that can push to main.
## Gotchas I Hit
**The daemon doesn't restart automatically after a crash.** On Linux, set up a systemd service wrapper so it comes back up without manual intervention:
openclaw service install systemctl enable openclaw
```Memory files grow fast. After a week, my ~/.openclaw/memories/ directory was already 200MB. Set a retention policy:
openclaw config set memory.retention_days 30
```**Heartbeat tasks can stack up.** If a scheduled task takes longer than the interval, it doesn't wait — it just fires again. Set `max_concurrent_heartbeats: 1` in config.json if you're running expensive tasks.
**Port 18789 should not be public.** The dashboard has no auth by default. If you're running on a VPS, either firewall the port or put it behind a reverse proxy with basic auth.
## The Bigger Picture
What OpenClaw represents isn't just another tool. It's the first serious infrastructure for personal autonomous agents that doesn't require you to give your data to a cloud service. The LLM runs remote (for now), but your memory, your files, your workflows — all local.
This is the model I've been building toward in my own work on [LaunchSuite](https://iamamitkumar.dev/projects/launchsuite) and [SprintLabs](https://iamamitkumar.dev/projects/sprintlabs): AI systems where the developer controls the stack, not the other way around. OpenClaw is the personal-use version of that idea, and it's surprisingly production-ready after only a few months of community development.
250,000 GitHub stars in 60 days isn't hype. It's recognition.
## What's Next
If this guide helped you get running, here's where to go deeper:
- [**GitHub — openclaw/openclaw**](https://github.com/openclaw/openclaw) — the actual README is excellent and more detailed than most third-party guides
- **Building custom skills** — I'll cover this in a follow-up post (subscribe below to catch it)
- **Running OpenClaw on a VPS with NemoClaw** — always-on agent setup on a $6/month server
*I write about building AI agents and agentic systems — the real implementations, not the demo reel. If you found this useful, subscribe to the Signal Dispatch newsletter for weekly deep-dives like this.*
*follow me on X*