Six weeks ago, my AI workflow looked like this: ChatGPT for coding questions, Claude for writing, a Telegram bot for quick mobile queries, a Discord bot I half-built for my server, and a WhatsApp number I'd set up with some random API wrapper that broke every Tuesday. Five apps. Five different conversation histories. Five places where I'd explain who I am, what I'm working on, and what "that project" refers to.
I'd ask Claude to refactor a function, then switch to ChatGPT on my phone to ask a follow-up — and it had zero context. I'd paste the same code snippet into three different windows. My AI assistants knew nothing about each other. They were five strangers sharing one brain.
The breaking point came on a Saturday morning. I was at a coffee shop, phone only. I needed to check if a deployment went through, ask about a weird log line, and draft a Slack message to my team. That's three AI conversations across three apps, on a 6-inch screen, while my coffee got cold.
I thought: There has to be a single thing I can message from anywhere, and it just knows me.
That thing turned out to be OpenClaw.
What OpenClaw Actually Is
OpenClaw is a self-hosted AI agent gateway. It's not another chat app. It's not another AI model. It's the plumbing that connects every messaging platform you already use to a single AI agent that runs on your own hardware.
Here's the mental model: imagine a central hub sitting on your machine (or a VPS, or a Raspberry Pi — it doesn't care). That hub maintains live connections to WhatsApp, Telegram, Discord, Slack, Signal, iMessage, and a dozen other platforms simultaneously. When you send a message from any of those apps, it routes to one agent. One brain. One memory.
You (WhatsApp) ──┐
You (Telegram) ──┤
You (Discord) ──┼──→ OpenClaw Gateway ──→ AI Agent (your config, your tools, your memory)
You (Slack) ──┤
You (iMessage) ──┘
The Gateway is the control plane. It owns all the messaging sessions, routes inbound messages to the right agent, manages tool execution, handles memory, and streams responses back to whichever app you're using. You talk from WhatsApp, it answers on WhatsApp. You switch to Telegram mid-thought, it picks up the thread.
It's built by Peter Steinberger and the community, it's MIT-licensed, and it's one of the fastest-growing open-source AI agent projects on GitHub — which tells you two things: people want this, and it works.
The 5-Minute Install
I'm allergic to complex setups. If a tool needs a 40-minute tutorial to get running, I'm out. OpenClaw surprised me.
What you need:
- Node.js 24 (recommended) or Node 22.19+
- An API key from any model provider (OpenAI, Anthropic, Google, etc.)
- 5 minutes
Install and run:
npm install -g openclaw@latest
openclaw onboard --install-daemon
That's it. The onboarding wizard walks you through picking a model provider, pasting your API key, and configuring the Gateway. It installs as a daemon (launchd on macOS, systemd on Linux) so it stays running across reboots.
Verify it's up:
openclaw gateway status
Open the built-in dashboard:
openclaw dashboard
You're looking at a browser-based control UI. Type a message. Get a response. You now have a working AI agent.
The whole thing took me about 4 minutes, including the time I spent squinting at my API key to make sure I copied it right.
Connecting Your First Channel
The dashboard is fine for testing, but the real magic is talking to your agent from apps you already have open. I started with Telegram because it's the fastest to set up — you just need a bot token from @BotFather.
# In your OpenClaw config (openclaw onboard handles this, but here's the raw version)
channels:
telegram:
token: "your-bot-token-here"
Restart the gateway, send a Telegram message to your bot. It replies. Instantly. With the same context, same memory, same personality as the dashboard.
Then I connected Discord. Then WhatsApp. Each one took under 5 minutes. The docs have step-by-step guides for every channel:
| Platform | Setup Time | What You Need |
|---|---|---|
| Telegram | 3-5 min | Bot token from @botfather |
| Discord | 5 min | Bot token from Discord Developer Portal |
| Slack | 5 min | Slack app + bot token |
| 5 min | Phone number (via Baileys) | |
| Signal | 5 min | Signal CLI linked device |
| iMessage | 10 min | macOS with BlueBubbles or similar |
| WebChat | 0 min | Built into the dashboard |
The full list includes Matrix, Google Chat, Microsoft Teams, IRC, LINE, Mattermost, WeChat, QQ, Feishu, Nostr, Twitch, and more. I haven't tried them all, but the ones I have just work.
One Agent, Every Platform
Here's what changed after a week of using OpenClaw: I stopped thinking about which app to open. I'd be on my laptop, hit a question, and just open Telegram (which was already in my dock). Or I'd be on my phone and fire off a WhatsApp message. The agent didn't care. It answered wherever I asked.
But the real payoff was context persistence. On Monday, I asked the agent about a database migration via the web dashboard. On Wednesday, I referenced "that migration" from Telegram. It knew exactly what I meant. Same agent. Same memory. Different app.
This sounds small. It's not. It's the difference between having a personal assistant and having five strangers who each know one slice of your life.
The way OpenClaw handles this is elegant: the Gateway maintains per-session, per-sender isolation. Your WhatsApp conversation is separate from your Discord conversation, but they share the same agent's long-term memory. The agent remembers facts, preferences, and context across all channels — but each conversation thread stays clean.
The Memory System
This is where OpenClaw went from "useful tool" to "I can't go back."
The agent has two layers of memory:
Session memory — the conversation you're having right now. It knows what you said 10 messages ago in this thread.
Long-term memory — facts, preferences, and context that persist across sessions and channels. Tell it once that you prefer TypeScript over JavaScript, and it remembers. Mention your team's deployment schedule, and it brings it up when relevant.
The memory system stores everything locally on your machine. Your data doesn't leave your machine unless you explicitly configure it to.
In practice, this means:
- Week 1: I told the agent about my project structure, tech stack, and coding preferences.
- Week 2: I asked it to review a PR. It already knew our conventions. No re-explaining.
- Week 3: I asked for help debugging a race condition. It remembered the async patterns we'd discussed before and suggested a fix that matched our style.
It felt like onboarding a new team member who actually paid attention.
You can also manually manage memories:
# List stored memories
openclaw memory list
# Search memories
openclaw memory search "deployment schedule"
# Add a specific memory
openclaw memory add "Production deploys happen Tuesdays at 2pm UTC"
The agent also does memory maintenance during heartbeats — periodic check-ins where it reviews recent conversations, distills important facts, and updates its long-term memory. It's like watching someone review their journal and update their mental model. Daily files are raw notes; long-term memory is curated wisdom.
What surprised me most: the agent started noticing patterns I hadn't. After a few weeks, it pointed out that I always asked about deployment status on Monday mornings and suggested it could proactively check and report. I said yes. Now every Monday at 9 AM, I get a Telegram message with the staging and production status. I didn't build that workflow. The agent suggested it because it remembered.
Cron Jobs and Automation
One feature I didn't expect to use as much as I do: scheduled tasks. OpenClaw has a built-in cron system that lets the agent run tasks on a schedule.
# Check for new GitHub issues every morning at 8am
openclaw cron add --schedule "0 8 * * *" --message "Check for new GitHub issues in openclaw/openclaw and summarize any critical ones"
# Remind me about standup every weekday at 9:45am
openclaw cron add --schedule "45 9 * * 1-5" --message "Standup in 15 minutes. Here's what you worked on yesterday and what's planned for today."
The cron system integrates with the agent's full tool suite. A cron job can search the web, check APIs, run shell commands, and then deliver the result to whatever channel you want. It's like having a cron job that can think about what it finds.
I have about a dozen cron jobs running. Some are simple reminders. Others are complex — one checks three different monitoring dashboards, cross-references the results, and only messages me if something looks off. Building that as a traditional script would have taken an afternoon. I described it to the agent in two sentences.
Voice: The Underrated Feature
If you're on macOS or have an iOS/Android node paired, OpenClaw supports voice input and text-to-speech output. Speak your question, get a spoken answer. It integrates with TTS providers for high-quality voice output, and falls back to system TTS if you don't have a premium voice key.
I use this while cooking. Hands covered in flour, need to know if I can substitute baking powder for baking soda. "Hey, can I swap baking powder for baking soda in this recipe?" — spoken answer, no screen required.
It sounds like a small thing. It's not. Voice changes the relationship with the agent from "tool I use" to "assistant I talk to."
Tools: Giving the Agent Hands
An AI that just talks is a chatbot. An AI that does things is an agent. OpenClaw is firmly in the second category.
The agent ships with a built-in tool suite:
- Shell execution — run commands, manage files, deploy code
- Browser automation — browse websites, fill forms, take screenshots
- Web search — search the web for current information
- File operations — read, write, edit files on your system
- Cron jobs — schedule recurring tasks
- Canvas — a live, agent-driven visual workspace
- Sub-agent orchestration — spawn specialized agents for complex tasks
Here's a real example from my workflow. I asked the agent (via Telegram, while walking to get lunch):
"Check if the staging deploy went through, and if there are any errors in the last hour of logs."
It ran the commands, parsed the output, and replied:
"Staging deploy completed at 14:32 UTC. Two warnings in the last hour — both are the known Redis connection timeout on startup. No new errors. Looks clean."
I didn't open a terminal. I didn't SSH into anything. I sent a message from my phone and got an answer.
Skills: Pluggable Capabilities
OpenClaw has a skill system through ClawHub — a registry of community-built capabilities. Skills are like plugins that teach the agent new tricks: GitHub integration, email management, calendar access, data analysis, and hundreds more.
Installing a skill:
openclaw skills install github
The agent now knows how to interact with GitHub — create issues, review PRs, check CI status — all through natural language.
Multi-Agent Routing
This one's for the power users. OpenClaw supports multi-agent routing — different channels or senders can be routed to different agents, each with their own workspace, personality, and tool access.
Why would you want this? A few scenarios:
- Work vs. personal: Route your Slack messages to a "work agent" that knows your team's context. Route WhatsApp to a "personal agent" that manages your side projects.
- Different expertise: Have a "coding agent" with full shell access for your DMs, and a "content agent" with writing tools for your Telegram channel.
- Team sharing: If you expose the gateway (with proper security), different team members can hit different agents with isolated sessions.
Configuration is straightforward:
agents:
routing:
- match:
channel: slack
workspace: work
agent: work-agent
- match:
channel: whatsapp
agent: personal-agent
Each agent gets its own workspace directory, memory namespace, and tool permissions. They're completely isolated.
How It Compares
I've tried most of the alternatives. Here's my honest take:
vs. ChatGPT/Claude apps: These are great for one-off conversations. But they're siloed. No cross-platform continuity. No tool execution on your machine. No self-hosting. You're renting an assistant; with OpenClaw, you own it.
vs. Coze / Dify: These are workflow builders — visual drag-and-drop platforms for building AI pipelines. They're powerful but heavy. They're designed for building products, not for having a personal assistant. OpenClaw is opinionated: it's a single-user agent, not an app builder.
vs. n8n / Zapier: Automation platforms. Great for connecting APIs, but they're not conversational. You build workflows, not relationships. OpenClaw is an agent you talk to that happens to be able to run workflows.
vs. Building your own: You could wire up a Telegram bot, a Discord bot, and a WhatsApp integration yourself. I've done it. It takes weeks and you end up maintaining three codebases. OpenClaw is the "just works" version of that project.
vs. Open WebUI: Open WebUI is a polished frontend for talking to LLMs. It's excellent at what it does. But it's a UI layer — it doesn't execute tasks, manage memory across platforms, or connect to messaging apps. OpenClaw has an Open WebUI integration if you want both: OpenClaw as the agent brain, Open WebUI as the chat interface.
The key differentiator for me: OpenClaw is local-first. Your data stays on your machine. Your agent runs on your hardware. You're not sending your conversation history through someone else's servers (except to the AI model provider, which is unavoidable). For a personal assistant, that matters.
The Canvas: A Surprise Hit
Canvas is an experimental feature, but it's already useful. I didn't expect to use it — it sounded gimmicky — a visual workspace the agent can render to?
Then I asked it to diagram a system architecture. Instead of generating a wall of text, it rendered an interactive diagram in the Canvas. I could see it, manipulate it, and ask the agent to modify specific parts. It was like pair-designing with someone who could draw.
The Canvas is served from the Gateway's HTTP server, so it works in any browser. The agent can push HTML, CSS, and JavaScript to it, and you can interact with the rendered output. It's particularly good for:
- System diagrams
- Data visualizations
- Interactive prototypes
- Dashboards the agent builds on the fly
I've since used it for quick data visualizations where I'd normally reach for a Jupyter notebook. Faster, more conversational, and the output is immediately visible.
The Canvas also supports A2UI (Agent-to-UI) — a protocol where the agent can push structured UI components, not just raw HTML. Think of it as the agent building a mini-app in real time, tailored to exactly what you asked for. I used it to build a live monitoring dashboard for a project in about 30 seconds of conversation. No code from me. Just "show me the health of these services" and the agent rendered it.
Security: The Uncomfortable Conversation
Let's be real: giving an AI agent shell access to your machine is a big deal. OpenClaw takes this seriously, but you need to understand the trust model.
Default behavior: The agent runs with full access to your host for the main session. This is intentional — it's a personal assistant, and you're the only user.
Sandboxing: For non-main sessions (group chats, shared channels), you can enable Docker-based sandboxing:
agents:
defaults:
sandbox:
mode: "non-main"
The sandbox restricts tool access — by default it allows file operations and session management but blocks browser, canvas, cron, and gateway commands.
Pairing: By default, unknown senders get a pairing code. The agent won't process their messages until you approve them. This prevents random people from messaging your WhatsApp bot and getting your agent to do things.
Remote access: If you expose the gateway beyond localhost, use Tailscale or an SSH tunnel. The docs have a detailed exposure runbook. Don't skip it.
My setup: the gateway runs on a VPS with Tailscale. I access it from my laptop and phone over the Tailnet. No public ports. No Docker (I'm the only user). It's been rock-solid for six weeks.
What I'd Change
No tool is perfect. Here's what I'd improve:
Initial channel setup could be smoother. The onboarding wizard is great for the gateway, but connecting channels still requires digging into platform-specific developer portals (Discord, Slack, etc.). A guided flow for each channel would help.
Mobile companion apps are maturing. iOS and Android "nodes" exist and work, but they're newer than the desktop experience. Voice wake on macOS is polished; mobile voice is catching up.
Documentation is extensive but sometimes scattered. The docs site is comprehensive, but I occasionally found myself jumping between three pages to answer one question. A "cookbook" section with common recipes would be useful.
None of these are dealbreakers. The core product is solid, and the community moves fast. I've seen features land in weeks that would take months in corporate projects.
Getting Started Today
If you've read this far, you probably relate to the "five apps, five strangers" problem. Here's my recommendation:
-
Install OpenClaw —
npm install -g openclaw@latest && openclaw onboard --install-daemon - Connect one channel — Telegram is the fastest (3-5 minutes, one bot token)
- Use it for a week — ask it things, let it learn your preferences, give it small tasks
- Add more channels — WhatsApp, Discord, whatever you actually use
- Explore skills — browse ClawHub and install what fits your workflow
The agent gets better as it learns about you. The first day is just a chatbot. By the end of the first week, it's an assistant. By the end of the first month, it's the one you reach for first.
The Bigger Picture
We're in a weird moment in AI. The models are incredible, but the experience of using them is fragmented. Every platform wants you in their app, their ecosystem, their walled garden. OpenClaw is a bet on a different model: you own the agent, you own the data, you choose the channels.
It's not trying to replace ChatGPT or Claude. It's the layer that makes them work together, on your terms, from wherever you happen to be.
Six weeks in, I've deleted three AI apps from my phone. I have one number, one bot, one agent — and it knows me across every screen I own.
That Saturday morning at the coffee shop? I opened WhatsApp, sent three messages, and had my answers before the barista called my name. One app. One brain. Coffee still hot.
And the best part? I didn't explain anything. The agent already knew.
OpenClaw is open source (MIT) and available at github.com/openclaw/openclaw. Docs at docs.openclaw.ai. Community on Discord.
Have you tried self-hosting an AI agent? I'd love to hear about your setup in the comments.
Top comments (0)