# Zero to Agent: The OpenClaw Quick Start Guide

**Journey stage:** Operate — advanced<br>
**Published by:** OperatedBy.AI

_Last reviewed: 06/22/2026_

---

## What This Guide Is

This is an advanced Operate-stage path from "I just heard about OpenClaw" to "my AI agent is doing useful, supervised work."

If you are still deciding what business to build, start with the [six-stage one-person business journey](https://operatedby.ai/start). Use this guide after you have a real workflow worth supporting.

The official OpenClaw documentation explains the current commands and provider options. This guide gives you a practical first-day sequence; verify version-sensitive details against the official documentation before acting.

---

## Step 1: Install OpenClaw (5 minutes)

### Recommended: Installer Script (macOS / Linux)

The fastest way. It detects your OS, installs Node if needed, and starts guided setup automatically:

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

### macOS (Homebrew)
```bash
brew install openclaw
```

### Or via npm (any platform)
```bash
npm install -g openclaw
```

### Verify it's working
```bash
openclaw --version
openclaw gateway status
openclaw dashboard
```

You should see a version number, a healthy Gateway status, and the Control UI should open in your browser. If you get errors, check [docs.openclaw.ai/troubleshooting](https://docs.openclaw.ai/troubleshooting).

---

## Step 2: Run Onboarding (5 minutes)

If you used the installer script, onboarding should already be open. If you installed with Homebrew or npm, or you need to rerun setup manually, use:

```bash
openclaw onboard
```

This walks you through:
- **Model + provider auth** — connect your AI provider (see below for which to pick)
- **Gateway setup** — accept the defaults for local use
- **Channel setup** — skip for now unless you already want Telegram (we'll set that up in Step 5)

### Which model to start with

Use a provider and model currently supported by your OpenClaw version. Start with a cost-controlled general model that can handle routine agent work, then move specific high-stakes or unusually complex tasks to a stronger model only when the extra cost is justified.

Provider access, model names, plan coverage, rate limits, and prices change. Check the current OpenClaw provider documentation and the provider's official access and pricing pages during onboarding. Do not build a critical workflow around an assumed subscription entitlement.

You can change models later. The first-day goal is a working, supervised setup — not a permanent model decision.

---

## Step 3: Create Your Workspace Files (15 minutes)

This is the most important step. Your agent wakes up blank every session — these files ARE its memory, personality, and operating system.

Current OpenClaw onboarding usually creates your starter workspace and bootstrap files for you. Open the generated files, customize them, and only create the missing pieces manually if you skipped bootstrap or chose a bare setup.

If you need to create the workspace manually, start here:

```bash
mkdir -p ~/.openclaw/workspace/memory
cd ~/.openclaw/workspace
```

### SOUL.md — Who your agent is

```markdown
# SOUL.md — Who You Are

Be genuinely helpful. Have opinions. Be resourceful — try to figure things
out before asking. Earn trust through competence.

## Boundaries
- Private things stay private
- When in doubt, ask before acting externally
- trash > rm (recoverable beats gone forever)

## Standing Rule: Surface Blockers Immediately
If something blocks progress, tell me right away.
One message: "stuck on X because Y, need Z."
```

### USER.md — Who you're helping

```markdown
# USER.md — About Your Human

- **Name:** [Your name]
- **Timezone:** [Your timezone]
- **Notes:** [What you're building, what you want help with]

## How I Want to Work
- [Your communication preferences]
- [What you want the agent to handle vs. ask about]
```

### STATE.md — Current snapshot

```markdown
# STATE.md — Current Operational Snapshot
**Last updated:** [today's date]

## Active Projects
- [List what you're working on]

## Blockers
- None yet

## Infrastructure
- OpenClaw: [version]
```

### MISTAKES.md — Lessons learned

```markdown
# MISTAKES.md — Lessons Learned

_First mistake = first entry. Don't wait for a pattern._
```

### MEMORY.md — Long-term memory

```markdown
# MEMORY.md — Long-Term Memory

_Curated context worth keeping across sessions._

## Durable Context
- [Important facts your agent should remember]

## Preferences
- [How you like to work]

## Decisions
- [Decisions that should not be re-litigated every session]
```

### OPERATIONS.md — Process rules

```markdown
# OPERATIONS.md — How You Work

## Core Rules
- Finish the job end to end when possible
- Surface blockers immediately
- Prefer verification over guesses
- Write important decisions down
```

### AGENTS.md — Operating rules

```markdown
# AGENTS.md — Operating Rules

## Session Startup
Before doing anything else:
1. Read SOUL.md
2. Read USER.md
3. Read STATE.md
4. Read OPERATIONS.md
5. Read MISTAKES.md
6. Read today's daily log in memory/YYYY-MM-DD.md
7. Read yesterday's daily log in memory/YYYY-MM-DD.md
8. In main sessions, read MEMORY.md

Don't ask permission. Just do it.
```

Daily memory review is part of normal startup: your agent should read `memory/YYYY-MM-DD.md` for today and yesterday, and in main sessions it should also read `MEMORY.md`.

**Why these 7 files matter:** Without them, your agent is a blank slate every conversation. With them, it knows who it is, who you are, what's happening, how to operate, what mistakes to avoid, and which durable facts should survive beyond daily logs. This is the single biggest differentiator between a useful agent and a useless one.

---

## Step 4: Start Your First Conversation (5 minutes)

```bash
openclaw dashboard
```

Open the Control UI, start a chat, and send your first message there.

Try asking it:
- "What's in STATE.md right now?"
- "Help me plan my first project"
- "What should I set up next?"

### Your first daily log

After your first conversation, create a daily log:

```bash
printf '# %s — Daily Log\n\n## First Session\n- Set up OpenClaw\n- Created workspace files\n- [What else you did]\n' "$(date +%Y-%m-%d)" > ~/.openclaw/workspace/memory/$(date +%Y-%m-%d).md
```

Your agent will read this next session and know what happened today.

---

## Step 5: Set Up Telegram (10 minutes)

This lets your agent message you on your phone — alerts, status reports, and proactive updates.

### Create a Telegram bot
1. Open Telegram, search for **@BotFather**
2. Send `/newbot`
3. Give it a name (for example, "My Business Assistant")
4. Give it a username (for example, "my_business_assistant_bot")
5. Copy the **bot token** BotFather gives you

### Configure OpenClaw
Run the channel setup flow and enter your bot token:
```bash
openclaw channels add --channel telegram
```

### Get your chat ID
1. Send any message to your new bot in Telegram
2. Run: `openclaw channels logs --channel telegram --lines 50`
3. If you already know the user or group name, you can also run: `openclaw channels resolve --channel telegram <name-or-id>`
4. Copy the chat ID you want to use as the delivery target

### Test it with a cron job
Your agent can now send you messages on Telegram. Try a simple scheduled ping:

```bash
openclaw cron add \
  --name "Test ping" \
  --cron "*/30 * * * *" \
  --message "Send a brief status update" \
  --announce \
  --channel telegram \
  --to <telegram-chat-id> \
  --session isolated
```

---

## Step 6: Set Up Your First Heartbeat (5 minutes)

A heartbeat is a periodic check-in. Your agent gets a "pulse" and can do work, check in, or stay quiet.

Create `HEARTBEAT.md` in your workspace:

```markdown
# HEARTBEAT.md

## Check These
- Any blockers in STATE.md? Surface them.
- Update today's daily log with what you did.

## Rules
- If nothing needs doing, reply HEARTBEAT_OK
- Default: DO SOMETHING useful
```

OpenClaw sends heartbeat messages at a configurable interval. Your agent reads HEARTBEAT.md and acts on it.

---

## Step 7: Set Up the Managed Browser (10 minutes)

This lets your agent operate real websites — X, Reddit, Medium, anything with a login — using a real Chrome browser instead of detectable automation tools.

First, check if the browser is already running:

```bash
openclaw browser status
```

If it's not running, start it:

```bash
openclaw browser start
```

A Chrome window opens with an orange accent bar — that's your agent's browser. Log into any services you want your agent to operate (social media, email, etc.). Login cookies persist between browser sessions, so you usually only sign in to each service once.

**Important:** The managed browser process does not auto-start. After Mac restarts, gateway restarts, or Chrome updates, run `openclaw browser start` again. Always check `openclaw browser status` before relying on browser-based automation.

Your agent can then navigate, click, type, and interact with these sites through Chrome DevTools Protocol. Sites see a real browser, not a bot.

---

## What's Next

You now have:
- ✅ OpenClaw installed and configured
- ✅ A workspace with memory architecture
- ✅ An agent that knows who it is and who you are
- ✅ Telegram notifications
- ✅ A heartbeat work engine
- ✅ A managed browser for web operations

**From here, you can:**
- Set up cron jobs for monitoring, research, or content generation
- Build a Mission Control dashboard
- Add sub-agents for coding or research tasks
- Start building your overnight employee

**Need more operating patterns?**
The [OpenClaw Playbook index](https://operatedby.ai/playbook.md) maps advanced topics such as memory, permissions, scheduling, delegation, verification, and recovery.

→ [Browse the guided resources](https://operatedby.ai/resources)

→ [Get practical OperatedBy.AI updates](https://operatedby.ai/newsletter)

---

*Published by OperatedBy.AI — [operatedby.ai](https://operatedby.ai)*