Run OpenClaw (Formerly Clawdbot or MoltBot) as Your Virtual Assistant

OpenClaw is an open-source framework for building a proactive AI assistant—one that acts, not just chats. It can run shell commands, edit files, call APIs, and work on its own through messaging apps like Telegram, WhatsApp, or Slack.

Try Apidog today

The project was previously known as Clawdbot and MoltBot. The name changed over time, but the core technology is the same—OpenClaw is the current, actively maintained name.

This guide walks through setup step by step. It takes some time, but you end up with an assistant that feels like a real part of your workflow.

💡 When you extend OpenClaw with custom APIs (weather, calendar, or your own services), use Apidog to design, mock, test, debug and document APIs in one place. Backend and full-stack developers can go from spec to working client code without switching tools—try Apidog free and keep your API workflow in a single platform.

What Is OpenClaw/Clawdbot/MoltBot?

OpenClaw is the main open-source project. Clawdbot was the first popular release; MoltBot was a short-lived name during a rebrand. Whether you see "OpenClaw," "Clawdbot," or "MoltBot," they all refer to the same kind of virtual assistant you run on your own machine.

What it does: It sits between you (via a messaging app) and a large language model (usually Claude). You send a message; the agent interprets it, plans steps, and performs actions—opening browsers, editing files, sending emails, running scripts, and more.

Why developers use it:

• Runs locally — your data stays on your machine; you keep control and privacy.
• Remembers context — conversation history persists across sessions.
• Proactive — script it to act on a schedule or triggers.
• Chat-first — interact through Telegram, WhatsApp, or Slack; no new UI to learn.

⚠️ Security note: Because the agent can run commands and access your system, security matters. Run it in a container or VM when possible, and avoid giving it full access on your main computer.

Prerequisites

Prepare your environment before installation—the requirements are identical whether you call it OpenClaw, Clawdbot, or MoltBot:

• Hardware: A dedicated always-on machine (PC, Mac, Raspberry Pi, or VPS). Use one that runs 24/7 for true proactivity. Minimum specs: 8GB RAM, multi-core CPU, stable internet.
• Operating system: macOS, Linux (Ubuntu/Debian recommended), or Windows (with WSL for best results).
• Dependencies: Node.js (v18+), npm/yarn, Git, and Docker (optional but recommended for isolation).
• API keys: An Anthropic API key (for Claude models) or equivalents from OpenAI/Groq/etc. Budget for usage—agentic tasks consume tokens quickly.
• Messaging app: Telegram Bot Token, WhatsApp Business API, Slack App, Discord Bot, etc.
• Security mindset: Run in a container or VM. Avoid granting unrestricted access on your primary workstation.

Install Node.js and Git first if you don't have them.

How to Run OpenClaw

Step 1: Install OpenClaw

Clone the official repository (or check openclaw.ai for the latest fork):

git clone https://github.com/moltbot/moltbot.git
cd moltbot

Then install dependencies:

npm install

This gives you the same codebase whether you think of it as OpenClaw, Clawdbot, or MoltBot.

Step 2: Configure Environment Variables

In the project root, create a .env file and add your keys:

ANTHROPIC_API_KEY=your_anthropic_key_here
TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
# Add other keys as required by the project (WhatsApp, Slack, etc.)

• Telegram: Get a bot token from @botfather.
• WhatsApp / Slack / Discord: Follow each platform's developer docs for tokens or webhooks.

Once this is set, the agent can receive messages and send them to the LLM.

Step 3: Enable Tools and Harden Security

OpenClaw supports tools for browser control, file access, shell commands, and more. Edit config/tools.ts or similar to enable specifics.

Many users activate dangerously-skip-permissions for seamless operation—this allows the agent to run commands without confirmation, so isolate the setup in Docker to contain the risk:

FROM node:20
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Then build and run:

docker build -t openclaw-assistant .
docker run -d --env-file .env openclaw-assistant

This safely contains OpenClaw (or Clawdbot/MoltBot) as your virtual assistant.

Step 4: Connect to Messaging Apps

Telegram setup:

1. Create a bot via @botfather.
2. Add the token to .env.
3. Start the agent:

npm start

1. Message the bot: "Summarize my inbox" or "Reschedule my 3pm meeting."

The agent processes via Claude, plans, and acts. Test simple queries first. For WhatsApp or Slack, configure webhooks or polling per the docs.

Step 5: Extend with Custom APIs

Add integrations by defining new tools in code that call external APIs—for example, a tool that queries a weather API or your custom service.

Apidog proves invaluable here. Use it to design your OpenAPI specs, mock endpoints during development, test requests, and generate client code. Download Apidog for free to accelerate this phase—its visual editor and AI-assisted features cut setup time significantly. Test and document the API in Apidog, then import it into OpenClaw.

Step 6: Run and Monitor

Launch the agent:

npm run dev

Monitor logs for errors and interact via your chosen app. The agent remembers context, so follow-up messages build on prior ones. Tune prompts in the config files—temperature, max tokens, etc.—for better performance.

Security Best Practices

Full system access introduces risks. Mitigate them:

• Run in Docker or a VM.
• Use separate user accounts.
• Monitor network traffic.
• Regularly review executed commands.
• Avoid sensitive data in prompts.

Many report smooth operation once isolated.

Troubleshooting Common Issues

• API rate limits: Upgrade your Anthropic plan or switch models.
• Connection drops: Ensure the machine stays online; use pm2 or systemd for persistence.
• Permission denied: Check the dangerously-skip-permissions flag.
• High costs: Limit proactive tasks and monitor usage.

Community forums and GitHub issues provide fixes.

Conclusion

You now have the knowledge to run OpenClaw (aka Clawdbot or MoltBot) as your virtual assistant. This setup transforms a simple LLM into a capable agent that handles real work through familiar chat interfaces.

The initial configuration requires technical effort, but the payoff is a personalized, always-available assistant under your control. Experiment iteratively: start small, add tools gradually, and prioritize security. If you integrate APIs, grab Apidog for free to handle design and testing efficiently.

Your proactive AI companion awaits—configure it today.