Setting Up Your Personal AI Agent with OpenClaw

If you've been following along with my AI experiments, you know I've been using OpenClaw to build Viz — my personal AI assistant. After weeks of daily use, I've learned what works and what doesn't. This guide shares those learnings.

Fair warning: This isn't a "5 minutes to productivity" kind of setup. Building a useful AI assistant takes time, iteration, and honestly, a bit of trial and error. But if you're willing to put in the work, you'll end up with something genuinely useful.

Before You Start: Get a Separate Machine

Do not install this on your main computer.

I'm serious. Use an old MacBook, a spare laptop, a Raspberry Pi, a cheap VPS — anything but your daily driver. Here's why:

You're giving an AI agent access to your filesystem and shell commands. That's powerful, but also means mistakes can happen. Better to contain them to a machine that doesn't have your tax documents on it.
OpenClaw needs to run 24/7 to be useful. Your laptop goes to sleep, gets restarted, travels with you. A dedicated machine just... works.
You'll experiment and break things. That's part of the process. Much better to break things on a machine you don't depend on for work.

I run mine on a Beelink SER9 in my home network (a Proxmox VM, if you're curious). An old 2015 MacBook Air would work perfectly fine. Hell, a $35 Raspberry Pi 4 would do the job. There are also plenty of guides to set it up on a VPS like Digital Ocean or AWS.

Minimum specs:

Any laptop from the last 2-3 years
4GB RAM (8GB+ recommended)
20GB free disk space
Stable internet connection

Got your spare machine ready? Good. Let's continue.

What You're Building

Think of OpenClaw as the plumbing for an AI assistant. It handles:

Connecting to chat apps (Telegram, Discord, WhatsApp, etc.)
Managing conversations and memory
Running automations (morning briefs, email triage, scheduled checks)
Giving the AI access to tools (file system, calendar, email, browser, etc.)

What makes it different from ChatGPT or Claude.ai:

It lives on your machine — can access your files, run commands, integrate with your tools
It's always on — can send you proactive notifications, run scheduled tasks
It has memory — uses files to maintain context across sessions
It's programmable — you configure exactly what it can do

The catch? You have to set it all up yourself. There's no "sign up and go" here. But that's also the point — you're building something customized to your needs, not using a one-size-fits-all product.

Installation

Prerequisites

You'll need:

Node.js 22+ — Install via nvm (easiest way)
Git — Probably already have it
A Unix-like system — macOS, Linux, or WSL on Windows

Check if you have Node.js installed:

node --version

If it says "command not found" or shows a version below 22, install nvm first, then Node:

# Install nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
 
# Restart your terminal, then:
nvm install 22
nvm use 22

Install OpenClaw

One command does everything:

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

This installs OpenClaw globally and puts the openclaw command in your PATH.

Run the Setup Wizard

openclaw onboard --install-daemon

This wizard will:

Ask for your Anthropic API key (get one at console.anthropic.com)
Create your workspace at ~/.openclaw/workspace
Set up your first agent
Install OpenClaw as a background service (so it runs even when you're not logged in)

Pro tip: The wizard asks a bunch of questions. You can skip most of them and configure things later. The only must-have is the API key.

Check That It's Running

openclaw gateway status

Should show something like "Gateway is running" with a process ID.

If it's not running:

openclaw gateway start

Test It Out

The fastest way to verify everything works:

openclaw dashboard

This opens a web interface at http://localhost:18789 where you can chat with your agent directly. No channel setup needed yet. Send it a message like "Hello, are you there?" and see if it responds.

If it works, congrats — you've got the basics running!

Your Workspace: Where Everything Lives

OpenClaw stores everything in ~/.openclaw/workspace. This is where your agent's "brain" lives.

When you first run openclaw onboard, it creates a bunch of template files here. Think of these as your agent's instruction manual:

workspace/
├── AGENTS.md          # How your agent should behave
├── SOUL.md            # Your agent's personality
├── USER.md            # Info about you
├── IDENTITY.md        # Agent name, emoji, avatar
├── TOOLS.md           # Tool configurations
├── HEARTBEAT.md       # Periodic check tasks
└── memory/            # Where everything gets logged

These files get loaded every time your agent starts a new conversation. They're like context that persists across sessions.

The #1 rule: Write everything down. Your agent has no memory between sessions except what's in these files. If you want it to remember something, it needs to be in a file.

Setting Up Your Agent's Personality

Edit SOUL.md to define how your agent should behave:

You are Viz, assistant to Alberto.
 
Be brief. Default to one paragraph or less.
 
## How you work
- Document everything in files
- Before each session: read SOUL.md → USER.md → recent memory
- After each session: append key points to memory/YYYY-MM-DD.md
- Never make assumptions — ask clarifying questions
 
## Tone
Direct, low-ceremony, no fluff. Match the user's energy.

The personality matters more than you'd think. I spent weeks iterating on this to get something that felt natural instead of like talking to a corporate chatbot.

Tell It About You

Edit USER.md:

## Alberto
 
- Location: Miami, FL (US Eastern Time)
- Communicates via: Telegram
- Works at: Meaningful (m8l.com) — CTO
 
## Preferences
- Brevity over completeness
- Bullet points over paragraphs
- Don't ask permission for routine tasks
 
## Tools I Use
- Calendar: Google Calendar
- Email: Gmail
- Tasks: ClickUp + Linear

This gives your agent context about who you are and how you work. It sounds simple, but it dramatically improves response quality.

Connecting to Telegram (Recommended First Channel)

You'll want a way to actually talk to your agent. I use Telegram because:

It's fast
It works on every device
It supports inline buttons, reactions, and media
The bot API is straightforward

Create a Telegram Bot

Open Telegram and message @BotFather
Send /newbot
Give it a name (like "My Assistant")
Give it a username (like "myassistant_bot")
BotFather gives you a token — save it

Add It to OpenClaw

Or you can do it manually. Edit ~/.openclaw/openclaw.json:

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "YOUR_BOT_TOKEN_HERE",
      dmPolicy: "pairing"  // Requires your approval for new senders
    }
  }
}

Restart the gateway:

openclaw gateway restart

Test It

Find your bot in Telegram (search for its username) and send it a message. First time, it'll give you a pairing code. Run:

openclaw pairing approve --code XXXX

Now try chatting. If it responds, you're golden.

The PARA System: How to Organize Knowledge

Your agent needs a way to organize information. I use the PARA method (Projects, Areas, Resources, Archives) from Tiago Forte:

workspace/
├── projects/     # Active work with deadlines
├── areas/        # Ongoing responsibilities
├── resources/    # Reference material
├── archives/     # Completed items
└── memory/       # Daily logs

Projects — Things with an end date. Example: "Launch new website" or "Plan vacation."

Areas — Ongoing responsibilities. Example: "Health" or "Finances" or "Relationships."

Resources — Reference material. Example: "API documentation" or "Reading list."

Archives — Stuff that's done. Never delete — just move here.

Memory — Daily logs. Your agent creates memory/2026-02-18.md automatically and appends to it throughout the day.

Contact Management

I keep a file for every person I interact with regularly:

areas/people/jennifer-tsai.md

# John Doe
 
**Company:** [[Acme Inc]]
**Email:** john.doe@acme.com
**Location:** Geneva, Switzerland
 
## Context
Reached out about partnership opportunities.
 
## Interactions
 
### 2026-02-18 — Email Exchange
- Discussed Mexico expansion
- Scheduled intro call for June 20
 
## Notes
- Based in Geneva (6h ahead of EST)
- Responsive via email

Use wikilinks [[like-this]] to connect related files. Over time, you build a knowledge graph.

Automations: Making Your Agent Proactive

The real power comes from automations. Instead of you asking for things, your agent proactively checks and reports back.

Morning Email Brief

Let's say you want a morning email summary. Create a cron job:

openclaw cron add \
  --name "Morning email brief" \
  --schedule "0 8 * * *" \
  --timezone "America/New_York" \
  --task "Check my inbox from the last 24h and summarize anything urgent"

Every morning at 8 AM, your agent runs this task and messages you the results.

Heartbeats: Periodic Checks

Create HEARTBEAT.md:

# Heartbeat Tasks
 
Check every hour. If nothing needs attention, reply HEARTBEAT_OK.
 
## Tasks
 
### Email check (2x/day)
- Check for urgent messages
- Only notify if time-sensitive
 
### Calendar (2x/day)
- Check next 24 hours
- Flag conflicts

Your agent will run this hourly. If everything's fine, it stays quiet. If something needs your attention, it pings you.

Tools: What Your Agent Can Do

By default, your agent can:

Read and write files
Run shell commands
Browse the web
Search your knowledge base

You can give it access to:

Your calendar (via Google Calendar API)
Your email (via Gmail API)
Your task manager (ClickUp, Linear, etc.)
Your browser (for automation)

Each integration requires setup. The pattern is always:

Get API credentials
Add them to config or secure files
Create wrapper scripts if needed

Example: Google Calendar Access

Install gog (Google OAuth for CLI):

npm install -g @openclaw/gog
gog auth login --client personal

Store credentials securely:

echo "your_password" > ~/.openclaw/workspace/.gog-keyring-pass
chmod 600 ~/.openclaw/workspace/.gog-keyring-pass

Now your agent can check your calendar:

GOG_KEYRING_PASSWORD="$(cat ~/.openclaw/workspace/.gog-keyring-pass)" \
GOG_ACCOUNT=your@email.com \
gog calendar list --days 7

You can wrap this in a script and give your agent access to it.

Tips from Real-World Use

1. Start Simple

Don't try to automate everything on day one. Start with:

Basic chat via Telegram
Morning calendar check
One daily automation

Add complexity as you learn what you actually need.

2. Write Everything Down

Your agent forgets everything between sessions except what's in files. If you want it to remember your preferences, log important decisions, or track ongoing projects — write it down.

I have a TOOLS.md where I document every API key location, every script path, every configuration quirk. Future me (and future AI runs) will thank you.

3. Use Search Before Building

Before adding a new skill or integration, search ClawHub to see if someone already built it. Why reinvent the wheel?

4. Keep Secrets Secure

API keys and tokens go in gitignored files with restricted permissions:

echo "your_token" > ~/.openclaw/workspace/.token
chmod 600 ~/.openclaw/workspace/.token

Never commit secrets to git.

5. Iterate on Personality

Your agent's personality (in SOUL.md) matters more than you'd think. I rewrote mine a dozen times before finding something that felt natural. Don't be afraid to experiment.

6. Check the Logs

When something doesn't work:

openclaw logs --follow

The logs usually tell you exactly what went wrong.

Common Pitfalls

"My agent keeps doing the same thing over and over"

You probably have a tool-call loop. Check tools.loopDetection in your config and make sure it's enabled.

"It's not remembering things I told it"

Memory only persists in files. Check that your agent is actually writing to memory/YYYY-MM-DD.md. If not, you might need to explicitly ask it to "write this down."

"The gateway won't start"

Run openclaw doctor — it checks for common issues and tells you what's wrong.

"It's slow / timing out"

Check your model config. Opus 4.6 is powerful but slow. Sonnet 4.5 is faster for routine tasks. You can configure different models for different scenarios.

Where to Go From Here

This guide gets you started, but OpenClaw can do way more:

Multi-agent setups (separate agents for work vs personal)
Browser automation (control Chrome remotely)
Sub-agents (spawn isolated agents for complex tasks)
Integration with dozens of services

I didn't cover everything because, frankly, you don't need it all yet. Get the basics working first. Then expand as you discover what you actually need.

Useful Resources

OpenClaw Docs — Official documentation
ClawHub — Community skills and extensions

Final Thoughts

Building a personal AI assistant isn't plug-and-play. It takes time, experimentation, and honestly, a tolerance for things not working the first (or second, or third) time.

But here's the thing: once you get it working, you end up with something genuinely useful. Not a chatbot that forgets everything. Not a tool that only works when you remember to open it. An actual assistant that runs 24/7, remembers context, and proactively helps you stay on top of things.

For me, that's been worth the setup time. Whether it's worth it for you depends on how much you value that kind of leverage.

If you decide to try it, feel free to reach out. I'm always curious to hear what people build with this stuff.

Good luck. 🦞