OpenClaw First-Run Configuration: From Zero to Your First AI Conversation

Have you ever wanted to run your own personal AI agent—one that actually stays on your machine, respects your privacy, and talks to you through the apps you already use? That’s OpenClaw. But getting from “I just downloaded this” to “Hey, my AI just replied on WhatsApp” can feel like navigating a maze of configs and tokens. Let’s fix that.

This guide walks you through the entire first-run experience, step by step. We’ll go from a fresh installation through connecting your first LLM backend and messaging platform, culminating in your first real conversation with your local AI agent. No mysterious gaps. No assumptions. Just clear, practical steps you can follow in under 15 minutes.

What is OpenClaw, Really?

Before we dive into the setup, let’s understand what we’re building. OpenClaw is an open-source personal AI agent that runs entirely on your machine. Think of it as a middleman—a very smart middleman—between your messaging apps and your AI models.

Here’s the architecture at a glance:

• Your messaging platforms (WhatsApp, Telegram, Discord, Slack, etc.) send messages to the Gateway
• The Gateway (a Node.js daemon running locally) receives those messages and routes them to your configured LLM backend
• Your LLM backend (Claude, OpenAI, DeepSeek, Ollama, or others) processes the message and generates a response
• The response flows back through the Gateway to your original messaging app

The beauty? Everything sensitive stays local. Your conversations aren’t sent to some cloud service for logging. You control the entire pipeline.

Prerequisites: What You Need Before Starting

Let’s be honest about what’s required:

1. A machine with Node.js installed (version 16+). Check this by running node --version in your terminal.
2. At least one LLM backend credential ready. This could be:
3. A Claude API key (from Anthropic console)
4. An OpenAI API key
5. A local Ollama installation
6. Any other supported backend
7. Access to at least one messaging platform. We’ll use WhatsApp or Telegram as examples, but Discord and Slack work too.
8. About 10 minutes of uninterrupted time. Seriously, don’t try to do this while multitasking.

That’s it. You don’t need Docker (though you can use it). You don’t need multiple API keys. You don’t need to be a DevOps wizard. Just a little patience and curiosity.

Step 1: Install OpenClaw

The first thing you’ll do is get OpenClaw on your machine. Head to the official GitHub repository and grab the latest release, or clone it directly:

git clone https://github.com/openclaw/openclaw.git
cd openclaw
npm install

This installs OpenClaw and all its dependencies. The npm install step might take a minute or two—Node.js has a lot of packages to pull down. Grab some coffee.

Once that’s done, you’ve got the complete OpenClaw codebase on your machine. The core components are:

• Gateway (the Node.js daemon that routes everything)
• Dashboard (your control center at localhost:18789)
• Skills (defined in SKILL.md, these are the actions your AI can take)
• Memory system (three-tier setup: persistent, daily logs, context)
• Soul (SOUL.md—your AI’s personality and instructions)

Don’t worry about understanding all of these yet. We’ll touch on what matters for first-run setup.

Step 2: Start the Gateway

Now that OpenClaw is installed, let’s fire up the Gateway. This is the daemon that does all the heavy lifting.

npm start

This command starts the Gateway on your machine. You should see output that looks something like this:

OpenClaw Gateway starting...
✓ Memory system initialized
✓ Skills loaded (127 total)
✓ Dashboard listening on https://automateanddeploy.com:18789
✓ Gateway ready to accept connections

The exact output might vary slightly depending on your version, but the key lines are:

• Gateway ready: Your daemon is running
• Dashboard listening on localhost:18789: This is your control center

Leave this terminal window open. The Gateway needs to stay running for everything else to work. If you close it, your AI agent goes offline.

Pro tip: On production machines, you’ll want to run this with a process manager like pm2 or systemd so it stays alive even after restarts. But for now, keeping it in a terminal is fine for learning.

Step 3: Access the Dashboard

Open your browser and navigate to:

https://automateanddeploy.com:18789

You should see the OpenClaw Dashboard. This is your control center. The first time you load it, it’ll look fairly empty—no backends configured, no messaging platforms connected. That’s normal.

Here’s what you’ll see on the main Dashboard page:

Top navigation bar:

• Home (current page)
• Backends (where we configure LLM backends)
• Platforms (where we connect messaging apps)
• Skills (view and test your available skills)
• Memory (inspect the three-tier memory system)
• Logs (see what’s happening under the hood)

Main content area:

• A welcome message explaining what OpenClaw is
• Quick-start buttons to add a backend and connect a platform
• System status (is the Gateway running? Are any backends configured?)

This dashboard is your friend. Every configuration you make here is persisted to your ~/.openclaw/ workspace. You’re building your personal AI setup, and this is where you steer the ship.

Step 4: Connect Your First LLM Backend

Now let’s get an AI model connected. Click on the Backends tab in the Dashboard.

You’ll see a button labeled Add Backend. Click it.

A form appears. Here’s what you’re filling out:

Backend Type: [Dropdown: Claude, OpenAI, DeepSeek, Ollama, Custom]
Name: [A human-readable name for this backend, e.g., "Claude 3.5"]
API Key: [Your actual API key]
Model: [Which specific model to use]
Temperature: [How creative/random the responses are]
Max Tokens: [Maximum response length]

Let’s walk through each field using Claude as an example (the setup is similar for other backends):

Backend Type

Select Claude from the dropdown.

Name

This is just for you. Something like “Claude 3.5 Sonnet” tells you exactly what you’re using. This name appears in logs and the dashboard, so make it descriptive.

API Key

This is where your Claude API key goes. If you don’t have one:

1. Go to https://console.anthropic.com/
2. Sign in or create an account
3. Navigate to API Keys
4. Click Create Key
5. Copy the new key (it only displays once!)
6. Paste it here in the Dashboard

Security note: Your API key is stored locally in ~/.openclaw/config/backends.json. It never leaves your machine unless it’s being used to make API calls to Claude’s servers. OpenClaw doesn’t log or transmit your keys anywhere else.

Model

Claude has several models. For first-run, we recommend:

• claude-3-5-sonnet-20241022 (good balance of speed and intelligence)
• claude-3-opus-20250219 (slower, smarter, more capable)
• claude-3-haiku-20250307 (fastest, for quick responses)

Pick Sonnet. It’s the sweet spot for most use cases.

Temperature

This controls how “creative” the AI gets in its responses.

• 0.0 = deterministic, boring, perfect for factual tasks
• 1.0 = creative, random, fun for brainstorming
• 0.7 = the Goldilocks zone for most conversations

Set it to 0.7 for now. You can adjust later.

Max Tokens

This is the maximum length of a single response. Claude can go up to 4096 tokens (roughly 3000 words), but for a first conversation, let’s set it to 1024. Smaller responses train you to ask good follow-up questions.

Once you’ve filled all this in, click Save.

You should see a success message. Your Claude backend is now configured. The Dashboard shows it in a list with a green “Connected” indicator (assuming your API key is valid).

Why this matters: You’ve just bridged your local machine to a powerful AI model. Every message that flows through OpenClaw will now be able to access Claude’s intelligence. The Gateway knows how to talk to Claude. The connection is live.

Alternative: Ollama (Local Models)

If you don’t want to use an API (and you have Ollama installed locally), you can instead:

1. Select Ollama from the Backend Type dropdown
2. Set Name to something like “Llama 2 Local”
3. Leave API Key blank (Ollama doesn’t use keys)
4. Set Model to your Ollama model (e.g., llama2)
5. Set the Host URL to https://automateanddeploy.com:11434 (Ollama’s default)

Everything else is the same. Ollama is great if you care deeply about privacy or want to experiment without API costs.

Step 5: Connect Your First Messaging Platform

Here’s where your AI actually becomes useful. Let’s connect it to a messaging app so you can have a real conversation.

Click on the Platforms tab in the Dashboard.

You’ll see a button labeled Add Platform. Click it.

A form appears with:

Platform Type: [Dropdown: WhatsApp, Telegram, Discord, Slack]
Name: [Human-readable name]
Platform-Specific Config: [Varies by platform]

For absolute simplicity on first-run, let’s use Telegram. It’s the fastest to set up.

Setting Up Telegram

1. Select Platform Type: Choose Telegram
2. Name: Call it “My Telegram Bot” or similar

Now you need a Bot Token. Here’s how to get one:

1. Open Telegram on your phone or desktop
2. Search for the user @BotFather
3. Start a conversation with BotFather
4. Type /newbot
5. Follow the prompts:
6. Name your bot (e.g., “My OpenClaw Bot”)
7. Choose a unique username (e.g., “my_openclaw_bot”)
8. BotFather sends you a message with your bot token. It looks like: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
9. Copy this token and paste it into the Dashboard form

Once you’ve entered the token, click Save.

The Dashboard shows your Telegram platform as connected. OpenClaw is now listening for messages to your Telegram bot.

Testing the connection: Go to Telegram, search for your bot by its username (e.g., “my_openclaw_bot”), and start a chat. Send a simple message like “Hello”.

If everything’s set up correctly, your AI should respond. Magic! Your local agent just spoke to you through Telegram.

If nothing happens, jump to the Troubleshooting section at the end of this article.

Alternative: WhatsApp

WhatsApp is trickier but more practical if that’s where your friends are.

OpenClaw uses the WhatsApp Web bridge, which means:

1. You scan a QR code to link your personal WhatsApp to the OpenClaw instance
2. Messages to your WhatsApp account get intercepted and sent to the Gateway

The setup:

1. Select Platform Type: Choose WhatsApp
2. Name: “My WhatsApp”
3. A QR code appears on the Dashboard

Now:

1. Open WhatsApp on your phone
2. Go to Settings → Linked Devices
3. Click Link a Device
4. Point your phone’s camera at the QR code on the Dashboard
5. Approve the link

Once linked, WhatsApp Web (and thus OpenClaw) can send and receive messages on your behalf.

Important caveat: This is one-device setup. You can’t use WhatsApp Web elsewhere while OpenClaw is linked. It’s the trade-off for having your AI respond through your personal WhatsApp.

Step 6: Send Your First Message

You’ve got a backend. You’ve got a platform. Now let’s have a real conversation.

If you set up Telegram:

1. Open Telegram
2. Find your bot (by the username you chose)
3. Send a message: “Tell me a joke”
4. Wait a moment…
5. Your AI responds

If you set up WhatsApp:

1. Send a message to your own WhatsApp account from a friend (or yourself from another device)
2. The message goes through OpenClaw
3. Your AI generates a response
4. It appears in your WhatsApp chat

This is the core loop. Every message you send:

1. Enters the messaging platform (Telegram, WhatsApp, etc.)
2. Gets forwarded to the OpenClaw Gateway (running locally)
3. The Gateway looks up your configured backend (Claude, OpenAI, Ollama, etc.)
4. Sends the message to the LLM for processing
5. The LLM generates a response
6. OpenClaw sends it back to the messaging platform
7. You see the reply in your chat

All of this happens on your machine. No logs on someone else’s server. No third party analyzing your conversations. Just your AI, your data, your control.

Understanding the Memory System

Here’s where things get interesting. OpenClaw doesn’t just respond to individual messages—it remembers context.

The memory system has three tiers:

Tier 1: Persistent Memory

This lives in ~/.openclaw/memory/persistent/. It’s your AI’s long-term knowledge: facts about you, your preferences, running projects, important dates. This persists across sessions indefinitely.

Tier 2: Daily Logs

Each day, a new log file is created in ~/.openclaw/memory/daily/. Everything you discuss that day gets logged here. It provides context for follow-up conversations.

Tier 3: Context Window

This is the active conversation in RAM. It includes:

• The current message from you
• The previous 5-10 messages in the conversation
• Any relevant facts pulled from persistent memory

When you send a message, OpenClaw searches your persistent memory for relevant facts, includes recent conversation history, and sends all of that to the LLM. This gives Claude (or whatever model you’re using) the context it needs to respond thoughtfully.

Why this matters for first-run: Your first conversation will feel a bit light on context. Your persistent memory is empty. But after a few days of chatting with your AI, it’ll start remembering details about you, your work, your interests. It gets smarter the more you use it.

You can inspect the memory system in the Dashboard under the Memory tab. See what your AI knows about you. Add facts manually if you want. The memory system is fully transparent and under your control.

Skills: What Your AI Can Actually Do

OpenClaw comes with about 127 built-in skills. These are defined in SKILL.md and they extend what your AI can do beyond just talking.

Some examples:

• File operations: Read files, write notes, organize documents
• Web search: Look up current information
• Scheduling: Create calendar events, set reminders
• Data analysis: Process CSVs, generate reports
• System tasks: Check weather, control smart home devices (if configured)

For first-run, you don’t need to enable any of these. Your AI works perfectly well just generating text. But knowing they exist is useful. Later, you can enable the skills you actually need.

Click the Skills tab in the Dashboard to see what’s available. Each skill has documentation explaining what it does and what configuration (if any) it needs.

Personality: The SOUL System

OpenClaw has a personality system defined in SOUL.md. This file contains instructions that shape how your AI behaves:

• Tone and voice
• Values and ethics
• How it handles difficult topics
• Its knowledge domain and limitations

By default, OpenClaw uses a neutral, helpful personality. But you can customize it. Edit ~/.openclaw/soul.md to make your AI more formal, more casual, more technical, whatever suits you.

For example, you could add:

You are a Python expert with 10 years of experience.
You are sarcastic but helpful.
You believe in teaching people to fish, not giving them the fish.

Change SOUL.md, and your AI’s entire personality shifts. It’s remarkably powerful.

Deep Dive: How the Gateway Routes Messages

Now that you understand the basic setup, let’s peek under the hood at how OpenClaw actually works. This isn’t required knowledge for using it, but understanding the flow makes you a better troubleshooter.

When you send a message through any platform:

Step 1: Message Arrives at Platform
Your message enters Telegram, WhatsApp, Discord, or Slack. The platform receives it and (if it’s configured correctly) sends it to the OpenClaw Gateway.

Step 2: Gateway Receives and Decodes
The Gateway is listening on its configured ports. It receives the incoming message, decodes it (every platform sends data in a different format), and extracts the useful bits: who sent it, what they said, what platform it came from.

Step 3: Memory Search
The Gateway checks your persistent memory. It uses semantic search (fancy word for “finding relevant stuff”) to see if there are any facts about you, previous conversations, or context that matters for this message. These facts get loaded into the context window.

Step 4: Backend Selection
The Gateway checks your configuration to see which LLM backend to use for this message. You might have multiple backends configured (Claude for detailed work, Haiku for quick responses, Ollama for offline mode). The Gateway picks the right one based on your rules.

Step 5: API Call
The Gateway sends the message plus context to your chosen LLM backend. This is where the actual magic happens. Claude (or OpenAI, or whoever) reads everything and generates a thoughtful response.

Step 6: Response Processing
The LLM sends back a response. The Gateway formats it appropriately for the platform that sent the original message. Discord responses might use markdown. WhatsApp responses use plain text. Slack responses might use blocks.

Step 7: Memory Update
The Gateway adds this conversation exchange (your message + the AI’s response) to your daily log and checks if anything should be added to persistent memory. This is how your AI learns about you over time.

Step 8: Send Back
The formatted response goes back through the platform to you. In Telegram, it’s a bot reply. In WhatsApp, it’s an outgoing message. In Discord, it’s a channel message or DM.

The entire cycle typically takes 2-5 seconds, depending on the LLM backend and your internet connection.

Why this matters: Understanding this flow helps you debug. If a message isn’t getting a response:

• Is it reaching the Gateway? (Check Logs)
• Is the backend connected? (Check Backends tab)
• Is the memory search causing issues? (Unlikely, but you can clear memory if needed)
• Is the response being formatted correctly? (Check Logs for output)

Configuring Multiple LLM Backends

You’re not limited to one LLM backend. Many users configure several and switch between them depending on the task.

Here’s a common multi-backend setup:

Claude (default)

• Model: claude-3-5-sonnet
• Temperature: 0.7
• Max Tokens: 1024
• Use for: General conversation, writing, reasoning

OpenAI (backup)

• Model: gpt-4o
• Temperature: 0.7
• Max Tokens: 1024
• Use for: When Claude is rate-limited, image analysis (GPT-4 Vision)

Ollama Local (privacy mode)

• Model: llama2
• Temperature: 0.8
• Max Tokens: 512
• Use for: Offline conversations, testing, sensitive topics

You configure each one separately in the Dashboard, then set rules for when to use each. For example: “Use Claude for everything, but if I mention ‘offline’ in my message, use Ollama instead.”

To add a second backend:

1. Go to Backends in the Dashboard
2. Click Add Backend again
3. Configure the new one (different API key, different model)
4. Click Save

Both backends now appear in your Backends list, both showing as “Connected” or “Disconnected” depending on their status.

To switch which one is active for new messages, you can either:

• Set it as the default in settings
• Use platform-specific routing (Telegram uses backend X, Discord uses backend Y)
• Use message-based routing (messages containing “fast” use Haiku, messages containing “smart” use Opus)

This flexibility is powerful. You’re not locked into one AI provider or model.

Security Considerations for First-Run

You’re running an AI agent on your machine that connects to messaging platforms. Let’s talk about security briefly.

Your API Keys
OpenClaw stores API keys in ~/.openclaw/config/backends.json. This file is readable only by your user account. If someone gains access to your machine, they can read your keys. So:

• Don’t leave your machine unattended with OpenClaw running
• If you use a shared machine, consider running OpenClaw in a Docker container with isolated permissions
• Periodically rotate your API keys (especially if you think they might be compromised)

Your Messaging Platform Links
When you link WhatsApp or connect to Telegram/Discord/Slack, you’re giving OpenClaw access to send and receive messages on your behalf. If someone gains access to your ~/.openclaw/ directory, they could potentially use these links to message your contacts.

Solution: Run OpenClaw on a machine you trust. Don’t put it on a shared server without proper access controls. If you’re paranoid (and many of us are), consider running it on a separate machine that only you have access to.

Your Conversations
The beauty of OpenClaw is that conversations stay on your machine. Your daily logs and memory files are stored locally in ~/.openclaw/memory/. They’re not sent to OpenClaw’s servers or any third party. The only thing sent externally is the message itself (to your LLM backend like Claude) and a small amount of metadata (like “conversation happened at time X”).

If privacy is your top concern, use Ollama as your LLM backend. Everything stays local. Nothing leaves your machine except what you explicitly tell your AI to send (like if you ask it to email someone or post on social media—it can’t do that without explicit setup).

Performance Tuning for First-Run

By default, OpenClaw works fine on any modern machine. But if you want to optimize, here are some settings to tweak:

Reduce Max Tokens (faster responses)
If you’re getting timeout errors, reduce max tokens from 1024 to 512 or 256. Smaller responses come back faster, especially on slower internet connections.

Use a Faster Model (faster responses)
If you configured Claude, switch from Opus (smartest) to Sonnet (balanced) or Haiku (fastest). Haiku returns responses in 1-2 seconds. Opus might take 5-10 seconds.

Enable Local Caching (faster repeated answers)
If you ask your AI the same question repeatedly, OpenClaw can cache the response. Enable this in Settings → Performance. Your second ask gets an instant answer.

Reduce Temperature for Faster Inference (sometimes faster)
Temperature 0.0 (deterministic) sometimes infers faster than 1.0 (creative). It depends on the backend. Try both and see.

Switch to Ollama (fastest, no internet needed)
If you have Ollama installed locally, switch to a local model. Response time is limited only by your CPU, and there’s no network latency. Trade-off: responses might be less intelligent than Claude, but they’re blazingly fast.

None of these are required for first-run. OpenClaw works out of the box. But if you find yourself waiting for responses, these tweaks can help.

Common First-Run Issues and Solutions

Issue 1: “Dashboard won’t load”

Symptom: Going to localhost:18789 shows a connection error.

Solution:

1. Make sure the Gateway is still running (check your terminal)
2. Check that no other service is using port 18789
3. Try restarting the Gateway with npm start

Issue 2: “Backend is configured but messages aren’t getting responses”

Symptom: You send a message, but nothing happens. The Dashboard shows the backend is connected.

Possible causes:

• Your API key is invalid or has run out of credits
• The Gateway isn’t actually running (check the terminal)
• Your message platform connection is broken

Solution:

1. Click on the Backend in the Dashboard and test it (there should be a “Test” button)
2. Check the Logs tab for error messages
3. Restart both the Gateway and the platform connection

Issue 3: “WhatsApp/Telegram isn’t receiving responses”

Symptom: You send a message through the platform, but your AI doesn’t respond.

Possible causes:

• The platform connection is loose (Telegram token expired, WhatsApp link broken)
• The message isn’t making it to the Gateway
• The Gateway is responding, but the platform can’t send it back

Solution:

1. Check the Logs tab for “Platform error” messages
2. Re-authenticate your platform (get a fresh Telegram token, re-scan the WhatsApp QR code)
3. Make sure your platform is set to “Active” in the Dashboard

Issue 4: “Everything is configured but I’m getting timeout errors”

Symptom: You send a message, wait 30 seconds, and get a “Request timed out” error.

Possible causes:

• Your LLM backend is slow or overwhelmed
• Your internet connection is weak (if using an API)
• The message is very long and the model is struggling

Solution:

• If using an API, check your internet connection
• If using Ollama locally, check your CPU load
• Try sending shorter messages
• Switch to a faster model (Haiku instead of Opus)

Next Steps: What to Explore Now

You’ve got a working OpenClaw setup. Your AI is live. Here’s what to do next:

1. Have a real conversation: Spend 20 minutes chatting with your AI. Ask it questions. Give it tasks. See how it responds.

2. Check the Logs: Go to the Logs tab and watch the magic happen. See your message flow through the Gateway, hit the LLM backend, and come back as a response.

3. Explore Skills: Click the Skills tab and read about what’s available. If any sound useful, enable them and experiment.

4. Customize SOUL.md: Edit your AI’s personality. Make it sound like you. Give it specific expertise.

5. Read the Memory: Check what your AI has learned about you after a few conversations. In the Dashboard, go to Memory and browse the persistent knowledge base.

6. Add More Platforms: Once Telegram or WhatsApp feels solid, try adding Discord or Slack. The beauty of OpenClaw is that your AI becomes available everywhere.

7. Connect More Backends: Set up Ollama for truly private responses, or add OpenAI as a backup if Claude is rate-limited.

Wrapping Up

You’ve gone from zero to a fully functional personal AI agent in about 15 minutes. Your machine is now running its own intelligent assistant, connected to the apps you use daily, processing with the LLM backend you trust.

This is the power of OpenClaw: privacy, control, and flexibility, all running locally.

The first-run setup is just the beginning. As you use OpenClaw, you’ll discover edge cases, customize behaviors, and integrate it deeper into your workflow. The Dashboard becomes familiar. The logs become readable. The memory system starts containing real insights about you.

Welcome to the future of personal AI. It’s open-source. It’s yours. It’s running on your machine right now.