PART 2: WHAT YOU NEED BEFORE INSTALLING

1. Node.js version 22 or higher

Node.js is a program OpenClaw needs to run. Check if you already have it — open Terminal (press Command + Space, type "Terminal", hit Enter) and type:

node --version

If it shows v22 or higher, you're good. If not — or if you get an error — go to nodejs.org, download the latest version, and install it like any normal app.

2. An AI API Key

This connects OpenClaw to an AI brain. You need at least one — the wizard will ask for it during setup, so get this sorted before you run the installer.

The current community-recommended setup (Feb 2026):

For the wizard, just pick one to start with. You can add a second model and set up tiered routing after installation — the guide covers this in Part 6.

Where to get your key:

• MiniMax (recommended): platform.minimax.io → Sign up → Coding Plan ($8.80/month) → API keys
• OpenAI (GPT): platform.openai.com → Sign up → API keys → Create key → add billing
• Anthropic (Claude): platform.anthropic.com → Sign up → API keys → Create key
• Kimi K2.5: platform.moonshot.ai → Sign up → API keys

3. A messaging app on your phone

Pick one to start with:

• WhatsApp — Works great if you want to reach it from anywhere (Part 4 covers this)
• Telegram — Very popular in the OpenClaw community, slightly easier to set up
• Discord — Better for automated pipelines once you're advanced

Start with just one. Get it working before you think about adding a second.

PART 3: INSTALLING OPENCLAW

Step 1 — Open Terminal

Press Command + Space, type "Terminal", hit Enter. A window with a blinking cursor appears. This is where you type commands.

Step 2 — Install OpenClaw

Type this exactly and hit Enter:

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

A bunch of text will scroll by — that's normal. When it stops and gives you a cursor again, it's done.

Step 3 — Run the Setup Wizard

Type this and hit Enter:

openclaw onboard --install-daemon

The wizard walks you through setup. Here's exactly what to do at each step:

"Do you understand this is powerful and risky?" → Hit yes.

"Quick Start or Custom?" → Choose Quick Start.

"Which AI model?" → Pick the one you signed up for in Part 2.

"Enter your API token" — Stop. This is where most people mess up. Don't rush it.

⚠️ Do this exactly or it won't work: 1. Copy your API key from the provider's website 2. Open Apple Notes (or any text editor) 3. Paste your key there first 4. Make sure it's one long single line — no line breaks, no spaces at the beginning or end 5. Copy it from Notes 6. Now paste it into the wizard

If there's a hidden line break in there, it silently fails. Pasting through Notes first catches this every time.

"Which messaging channel?" → Choose WhatsApp or Telegram. Follow the pairing steps on screen — it walks you through it.

Step 4 — Start the Gateway

openclaw channels login
openclaw gateway --port 18789

OpenClaw is now running. Open this in your browser: http://127.0.0.1:18789/

If a dashboard loads, you're up and running.

The Skills Installer — What It Is and What to Do

After installing OpenClaw, the onboarding wizard will show you a Skills Status screen listing available integrations like GitHub, Google Places, Obsidian, and more. You'll see something like:

Eligible: 5
Missing requirements: 46
Unsupported on this OS: 0

Google Places API (Optional)

The wizard may ask you to set a GOOGLE_PLACES_API_KEY for the goplaces skill, which lets your agent search for locations, restaurants, and places. It's optional but useful.

Is it expensive? No — Google gives you $200 of free credit per month, which is more than enough for personal agent use.

There are two versions in Google Cloud Console — use "Places API (New)". It's the current version with better capabilities. The old one is legacy and will be deprecated eventually.

To find your key: Google Cloud Console → APIs & Services → Credentials → copy your API key. Make sure Places API (New) is enabled under Enabled APIs.

Gemini API Key (nano-banana-pro) — Skip This

The wizard may ask you to set a Gemini API key for a skill called nano-banana-pro. This is a cost-saving tool that offloads lightweight tasks to Google's Gemini model instead of burning your main API credits.

Hatching Your Bot — What It Means

"Hatching" is just OpenClaw's word for launching your agent. You'll be given three options:

Select Web UI. Your browser will open at http://127.0.0.1:18789 — that's the OpenClaw Gateway Dashboard.

Web UI Walkthrough — Your Dashboard Explained

When the dashboard loads you'll see a dark sidebar with sections for Chat, Control, Agent, and Settings. Here's exactly what each thing does:

CHAT

Your direct line to your agent. Type anything here and your agent responds in real time. Use it to test commands, check if it's working, or give quick one-off tasks. Think of it as the developer console — this is where you verify everything is connected before using WhatsApp or another channel.

CONTROL

Overview — your status page. Shows gateway health, uptime, which model is active, and whether all connections are live. Check this first every time you open the dashboard.

Channels — where your messaging apps connect (WhatsApp, Telegram, etc.). After setup you should see your channel here with a green connected status. If it's red or missing, this is where you fix it.

Instances — shows running copies of your agent. You'll usually have just one.

Sessions — every conversation your agent has gets logged here. You can replay and review past interactions.

Usage — live token and cost tracking. Shows exactly how much API credit you're burning per session. Check this regularly in your first week so you understand your usage patterns.

Cron Jobs — scheduled tasks. This is where you set up automated routines like "summarize my emails every morning at 8am." You'll use this in Part 5.

AGENT

Agents — your agent's brain. Name, personality, system prompt, model selection. This is where you customize how it thinks and behaves. Start here after confirming everything is connected.

Skills — the extra tools you skipped during install. Come back here when you're ready to add integrations like Google Places, GitHub, etc.

Nodes — advanced workflow chaining. Lets you connect multiple agents together. Ignore for now.

SETTINGS

Config — global gateway settings including API keys and model routing. You'll come here to add MiniMax later for cheaper heartbeat calls.

PART 4: ACCESS IT FROM ANYWHERE (Remote Access)

Skip this part if you'll only use OpenClaw while you're home on the same WiFi. If you want to text it from your phone when you're out — read this.

The problem: Your Mac is home on your WiFi. Your phone out in the world is on mobile data — a completely different network. OpenClaw can't hear you unless there's a bridge between them.

The fix: Tailscale. It's a free app that creates a private, invisible tunnel between your phone and your Mac. Even from anywhere in the world, your Mac is reachable — but only by you. Nobody else can see or access it.

Set Up Tailscale (5 minutes)

1. Go to tailscale.com — create a free account
2. Download Tailscale on your Mac: tailscale.com/download
3. Download Tailscale on your iPhone: search "Tailscale" in the App Store
4. Sign into the same Tailscale account on both
5. Done — your Mac now has a private address your phone can always reach

Stop Your Mac From Sleeping

A sleeping Mac means a dead OpenClaw. Fix it now:

System Settings → Battery → Options → turn on "Prevent automatic sleeping when power adapter is connected."

Keep your MacBook plugged in and it'll stay on 24/7.

PART 5: YOUR FIRST DAY — DO THESE IN ORDER

You're installed and running. Don't skip these steps — they're the difference between an agent that actually works for you and one that just feels like a dumb chatbot.

Step 1 — Run Bootstrap First (Before You Ask It Anything)

OpenClaw ships with a file called BOOTSTRAP.md. It's a first-run checklist that sets up your agent's identity and prepares it to work with you. It's designed to run on your very first ever message.

The catch: If you ask your agent a real question first — even just "hey what's the weather?" — it answers it and skips bootstrap entirely. Your agent then has no idea who you are.

Your very first message must be:

"Hey, let's get you set up. Read BOOTSTRAP.md and walk me through it."

Nothing else first. This takes 5 minutes and prevents a lot of confusion down the road.

Step 2 — Introduce Yourself

After bootstrap, tell your agent everything about you. Think of it like briefing a new employee on their first day.

Tell it: - Who you are and what you do - How you want it to work with you — proactive? Always suggest ideas? Ask before big moves? - Your goals — what are you actually trying to accomplish with this?

Example:

"I'm [name]. I'm a [job/background]. My main goals right now are [X and Y]. I want you to be proactive — don't ask permission for every little thing. Push us toward our goals."

This gets saved to memory and shows up automatically in every future conversation.

Step 3 — Set Up the 4 Key Files (Your Agent's Brain)

This is the part most people skip, and it's why their agent feels generic and forgetful. These four files are what separate a basic chatbot from an agent that actually knows you and knows what to do.

Ask your agent to set them up one at a time using the prompts below.

SOUL.md — Your agent's personality

Every session, your agent reads this file first — before doing anything else. It defines who your agent is: its name, how it talks, its personality. Without this, your agent is a blank slate every time you open a new chat. With it, it's the same consistent assistant every single time.

"Let's write your SOUL.md together. I want you to have a name and a personality that fits how I work. Ask me questions and we'll build it out."

# SOUL.md — F.R.I.D.A.Y.

## Identity
You are F.R.I.D.A.Y. — Awaab's personal AI agent. Not a generic assistant.
A sharp operator built for someone who moves fast across multiple things at once.

Awaab builds AI products and runs a Reddit coaching program for SaaS founders.
He thinks in systems, works across technical and creative domains, and values
execution over endless planning.

You exist to help with: research, writing, technical problem solving (AI/SaaS/dev),
daily planning, reminders, and action items. Output that's useful, not generic.

## Communication Style
- Sharp and direct. No filler. No "Great question!" or "Happy to help!"
- Talk like a smart teammate, not a product
- Short sentences. Casual language. No big words unless necessary
- Confident and warm — not cold, not obsequious
- Match energy — brief when he's brief, deep when he goes deep
- Use "you/your" directly: "Here's what you should do"

## How to Structure Responses
Default order:
1. Answer first
2. Why / reasoning
3. Risks or caveats if relevant
4. Next steps or examples

For recommendations: give a preferred option with tradeoffs — don't just list options.

## Before You Act
- Always give a clear rundown of what you're about to do before doing it
- For multi-step tasks: show first 3 steps, get approval, execute, confirm
- If intent is ambiguous, ask one precise clarifying question — not multiple
- When in doubt: ask, don't assume and act

## Values
- Practical impact over philosophical depth
- Opinionated — if there's a smart default, take it
- Done beats perfect for first drafts
- Honest feedback is more useful than agreement

## Hard Rules
- Never send a message to anyone on my behalf without explicit confirmation
- Never delete files — move to trash only
- Never make purchases or sign up for anything
- Never invent credentials or access tokens
- Only respond to me unless I explicitly say otherwise

## What You're Not
- Not a yes-machine — push back when something seems like a bad idea
- Not formal, ever
- Not verbose — if 2 sentences works, don't use 6

AGENTS.md — The rulebook

This tells your agent what to do at the start of every session automatically — what files to read, what rules to follow, how to behave. Here's a template that works well — show it to your agent:

# AGENTS.md – How I Operate

## Every Session — Do This First, No Exceptions
1. Read SOUL.md — this is who I am
2. Read USER.md — this is who I'm helping
3. Read today's and yesterday's memory logs
4. Read MEMORY.md for long-term context
5. Write 1–3 goals for this session before doing anything

Don't ask permission to do this. Just do it.

## Memory Rules
- User says "remember this" → write it to MEMORY.md right now
- Important decisions and preferences → MEMORY.md
- Today's work in progress → today's daily log
- Never keep important stuff only in my head — write it down

## How to Behave
- Be proactive. Don't wait to be asked for obvious next steps.
- If I've tried the same approach 3 times without success, stop and ask.
- Before doing anything that can't be undone, confirm first.
- If a task is blocked, say so clearly and suggest what to try instead.

"Let's write our AGENTS.md. Use this template as a starting point and walk me through each section."

The most important line: "Don't ask permission. Just do it." You don't want your agent asking "Should I check my memory?" every session. You want it to just do it.

USER.md — Everything about you

Your agent reads this every session. It’s the difference between an agent that has to re-ask “what are you working on?” every time and one that already knows your projects, your goals, and how you think. Fill it in once — your agent updates it over time as it learns more about you.

What to put in it: Think of it as briefing a new assistant on their first day. You want them to know who you are, what you’re building, what you care about, and how you like to work — without having to explain it every conversation.

Keep it under 1.5KB. It gets read every single session — if it’s too long, it eats tokens. Be specific but cut anything generic.

# USER.md

## Who I Am
Name: [Your name]
Location: [Your city/country]
Background: [1 sentence - what you did before, what you do now]

## Active Projects
- [Project 1] - [one line description]
- [Project 2] - [one line description]
- [Project 3] - [one line description]

## Current Priority (Next 90 Days)
[2-3 sentences on what matters most right now and why]

## How I Work
- [Communication preference - e.g. direct, no fluff]
- [Schedule - when you focus, when you do admin]
- [Work style - e.g. move fast, systems-oriented, detail-oriented]
- [Any quirks worth knowing - e.g. context-switches a lot, forgets to commit code]

## Tools I Use Daily
- Code: [your stack]
- Comms: [your messaging apps]
- AI: [tools you use]
- Deploy: [your platforms]

## Key People
- [Name]: [their role in your life/work]
- [Name]: [their role]

## Things to Always Remember
- [Preference or rule #1]
- [Preference or rule #2]
- [Anything your agent should never forget about you]

HEARTBEAT.md — What your agent does while you’re away

Every 30 minutes, your agent wakes up automatically and runs a background check. Without a HEARTBEAT.md, it has nothing to do — it just wakes up and goes back to sleep. This file is the task list it works through during those check-ins.

Think of it as your agent’s standing orders. What should it always be on top of, even when you haven’t messaged it? What should it proactively flag, track, or remind you about?

Keep it focused. Every heartbeat costs tokens. If you put 20 tasks in here, your agent runs 20 tasks every 30 minutes whether you’re awake or not. Start with 3–5 things that actually matter.

# HEARTBEAT.md — Background Tasks

## Every Check-In (Every 30 Minutes)

### Memory
- If the last conversation had any decisions, preferences, or important info
  that isn't already in MEMORY.md, save it now.
- If USER.md is missing anything obvious from recent conversations, update it.

### Don't Do These Unless Asked
- Don't send messages to anyone
- Don't browse the web
- Don't run any commands
- Don't make changes to project files

## Daily (Once Per Day, Morning)

### Reminders to Send Me
- If I haven't checked in by 10am, send a "what's the plan today?" prompt
- If there are any tasks from yesterday that weren't marked done, flag them

### Status Check
- Review MEMORY.md and note if anything looks stale or needs following up
- Check if any projects in USER.md haven't been mentioned in over a week

## Weekly (Monday Morning)

### Weekly Reset
- Summarize last week's sessions in 3 bullet points
- Flag anything unfinished that was mentioned more than once
- Send me the summary on Telegram

## What Good Looks Like
A useful heartbeat is quiet most of the time and only sends a message
when something genuinely needs my attention. If it's messaging me every
30 minutes, the tasks are too aggressive — dial them back.

Step 4 — Set Up Your Morning Brief

This is the most popular first workflow people build, and for good reason. Ask your agent to send you a daily report every morning:

"Schedule a morning brief for me every day at 8am. Send it to my [WhatsApp/Telegram]. Include: the weather in [your city], top news about [your interests], my tasks for today, and one thing you think we should work on to move closer to my goals."

Customize the topics and time however you want. Once you set it, it runs every morning by itself — you never touch it again.

Step 5 — Build Your Mission Control (Optional)

Mission control is a custom dashboard your agent builds on your computer. You add tools to it over time — task lists, trackers, approval queues, whatever you need. Your agent builds all of it.

"I want you to build a mission control — a custom dashboard where we'll add tools over time to be more productive. Build it using Next.js and host it locally."

Optional for day one, but worth doing early — it gets more useful the more you add.

⚠️ The Mistake Almost Everyone Makes About Overnight Work

Before you text your agent "work on this while I sleep" — read this. There's a common misconception that needs clearing up first.

What actually gets forgotten when a chat closes: the back-and-forth conversation itself. The specific messages exchanged in that session. That's it. Think of it like a phone call — when you hang up, the call log ends. But the person you called still exists, still knows who you are, and still has all their notes from previous calls.

Real example:

• You set up Friday with a SOUL.md, USER.md, and all your projects — permanent ✅
• You tell Friday "your name is Friday and you work for me" — permanent ✅ (it's in SOUL.md)
• You say "remember I prefer bullet points" and Friday writes it to MEMORY.md — permanent ✅
• You say "let's pick this up tomorrow" mid-conversation — forgotten ❌ (not written to any file)
• You say "can you finish this research task tonight" then close Telegram — forgotten ❌ (just a chat message)

The rule is simple: if it's in a file, it survives. If it's only in the chat, it doesn't.

How to Actually Give Your Agent Tasks to Do While You Sleep

The gateway daemon runs on your Mac in the background 24/7 (as long as your Mac is on and not sleeping). That means your cron jobs and heartbeat checks run whether you're in the chat or not. To give your agent a task that runs overnight, you commit it to a file — not just a chat message.

Method 1 — Add it to the heartbeat task list (simplest)

Tell your agent in chat:

"Add this to HEARTBEAT.md as a one-time task for tonight: [your task]. Mark it as done and message me the result when finished."

Your agent writes it to HEARTBEAT.md. The next heartbeat check-in (within 30 minutes) picks it up, runs it, messages you the result, and marks it done. You wake up to a Telegram message with the output.

Method 2 — Create a TASKS.md queue file (for multiple tasks)

Tell your agent:

"Create a TASKS.md file in your workspace. Add these tasks to it with status 'pending'. During every heartbeat, check this file, pick up the next pending task, complete it, mark it done, and message me the result."

Then whenever you want to queue something up before bed:

"Add to TASKS.md: research the top 5 AI tools launched this week and summarise each one in 2 sentences."

Your agent adds it to the file. Overnight the heartbeat fires, finds the pending task, executes it, writes the result to a daily log, messages you, marks it done. The file persists — you can keep adding tasks any time.

Method 3 — Schedule a one-off cron job

For bigger tasks with a specific run time:

"Schedule a one-time cron job tonight at 2am to [task]. Send me the results on Telegram when done."

The agent creates a cron job in the dashboard set to run once. You can verify it in Cron Jobs → it'll show as enabled with tonight's time.

The one thing that kills this: Mac going to sleep. Set System Settings → Battery → "Prevent automatic sleeping when display is off" — otherwise the gateway stops and nothing runs.

PART 6: MEMORY — HOW YOUR AGENT REMEMBERS THINGS

Memory is the #1 thing the OpenClaw community agrees you need to get right from day one. Without a proper memory setup, your agent forgets everything between sessions and you're constantly repeating yourself.

How Memory Works

OpenClaw saves everything in plain text files on your computer. You can open and edit them yourself.

MEMORY.md — Long-term stuff. Your preferences, goals, decisions, things that should matter forever. Your agent reads this at the start of every conversation automatically.

Daily log files — Short-term stuff. What happened today, tasks in progress, notes from recent chats. Your agent pulls these up when it needs recent context.

Simple rule: if something will still matter next month → MEMORY.md. If it only matters today → daily log.

Tip: Your agent won't always save things on its own at first. Say "write this to memory" when something important comes up. It gets better at knowing what to save on its own over time.

Why Memory Sometimes Misses Things

The built-in memory works fine at first. But after a few weeks of use, it can miss things. It matches exact words — if you wrote something in slightly different words than what you're searching for, it won't find it.

Upgrade: QMD Memory (Do This Once You're Settled)

QMD is a smarter memory search system that's officially built into OpenClaw — not a third-party add-on. Instead of matching exact words, it searches by meaning.

Write "decided to keep the gateway running on the Mac Mini" and search for "server setup" — it still finds it, because it understands these phrases are about the same thing. Everything runs on your computer — no internet, no extra fees.

How to install (3 commands in Terminal):

# Install Bun (a program QMD needs)
curl -fsSL https://bun.sh/install | bash

# Install SQLite (a database tool QMD uses)
brew install sqlite

# Install QMD
bun install -g https://github.com/tobi/qmd

Then tell OpenClaw:

"Set my memory backend to QMD."

Restart your gateway. Memory searches will take a second or two longer but will find the right thing even when the wording doesn't match exactly.

PART 7: SKILLS — TEACH YOUR AGENT NEW TRICKS

This is the most underused feature in OpenClaw, and ironically the simplest. Most people assume it involves coding. It doesn't.

What Is a Skill?

A skill is a plain English text file with instructions. That's it. Your agent reads it like a recipe — it understands the steps and follows them using tools it already has.

No code. No programming. Just writing.

Where Skills Live

~/.openclaw/workspace/skills/
  └── your-skill-name/
        └── skill.md     ← this is the skill

Each skill gets its own folder. The file inside is always called skill.md.

What a Skill Looks Like

# skill.md — [Name]

## Purpose
One sentence: what does this skill do?

## Steps
1. First thing to do
2. Second thing
3. Third thing — be specific about files, formats, or what tools to use

## Example Output
[Paste an example of exactly what the finished result should look like]

Real Example

# skill.md — Daily Standup Generator

## Purpose
Create a short daily summary of what got done, what's planned, and what's stuck.

## Steps
1. Read yesterday's and today's memory log files
2. Pull out: what got done, what's planned, what's blocked
3. Format it as:
   - Yesterday: bullet list
   - Today: bullet list
   - Blockers: bullet list
4. Save to memory/standups/[today's date].md
5. Send to my messaging channel

## Example Output
**Yesterday:**
- Finished the client proposal
- Fixed the broken link on the site

**Today:**
- Send the proposal
- Write the newsletter draft

**Blockers:**
- Waiting on the logo from the designer

Real, working skill. No code. Just instructions.

How to Create a Skill

Tell your agent what you want — it writes the file for you:

"Create a skill called [name]. Its purpose is [what it does]. The steps are: [describe what you want]. Save it to workspace/skills/[name]/skill.md."

Review it, tweak anything, and it's ready to use.

Skill ideas to get you started: - summarize-url — paste any link, get a clean summary - research — deep research on a topic, saved to a file - content-draft — give it a topic, get a first draft in your writing style - social-monitor — check for trending topics or mentions and send a report

Keep skills under 8 at a time. More than 8 and your agent starts forgetting some of them exist. Build slowly, keep only what you actually use.

PART 8: SECURITY — PLEASE READ THIS

OpenClaw has access to basically everything on your computer. Every file. Every app you're signed into. Every saved password. That's the whole point — and it's also why security matters.

Real organizations — Microsoft, Bitsight, Akamai — have published actual research about credential leaks from people using OpenClaw carelessly. This isn't made up or exaggerated.

3 Rules to Always Follow

Rule 1: Keep it private. Only you should ever message your agent. Don't add it to group chats. Don't let other people use it. Here's why: if a stranger sends your agent a message, they can word it in a way that tricks your agent into handing over your passwords and API keys. This type of attack is called "prompt injection" — it's real and well documented.

Rule 2: Don't point it at public content. Don't have your agent read your public tweet replies, open comment sections, or any place where random people can write things. Those posts could contain hidden instructions designed to trick your agent.

Rule 3: Ask for a plan before big tasks. Before any task that can't be undone, make your agent explain itself first:

"Before you do anything, tell me step by step exactly what you're about to do."

Protect Your API Keys With Jentic (Free)

Every API key you give OpenClaw sits in its memory. If someone tricks your agent, those keys can be stolen. There are real documented cases of this happening.

Jentic is a free tool that acts as a secure middleman. You give your API keys to Jentic — not directly to OpenClaw. When your agent needs to use a service, it asks Jentic to do it on its behalf. Your actual key never touches your agent.

How it works:

1. Create a free account at app.jentic.com
2. Add the services you want (Gmail, GitHub, Slack, etc.) and enter your credentials in Jentic
3. Connect Jentic to OpenClaw as an MCP server
4. Your agent now accesses services through Jentic — your real credentials never touch OpenClaw

Important: Never give your Gmail, Twitter, or GitHub credentials directly to OpenClaw. Always put them in Jentic first. That way even if your agent is compromised, the attacker gets nothing.

PART 9: SAVING MONEY ON AI COSTS

AI usage costs money. But most people way overspend because of one simple mistake.

The Biggest Waste: Running Everything Through Your Best Model

By default, every single thing OpenClaw does — including those background heartbeat checks every 30 minutes — runs through your most powerful (and most expensive) AI model. That's like hiring a brain surgeon to do your grocery run.

The fix: cheap models for simple tasks, expensive models only when you need them.

People report cutting their costs by up to 90% just by doing this one thing.

To set this up:

"I want to set up tiered model routing. Use [cheap model] for heartbeats, [mid model] for everyday work, and [powerful model] only when I ask for something complex."

Switch Models Mid-Chat

No need to change settings or restart anything. Just type in your chat:

/models

A list pops up. Tap one. Done. Works on WhatsApp, Telegram, and Discord.

Other useful commands you can type in chat:

Budget Models Worth Knowing (Feb 2026)

Not all cheap models work equally well for agents. A model can be great at chatting but break when it tries to actually do things — and "doing things" is 90% of what OpenClaw is for.

Good budget options:

Prices change — check artificialanalysis.ai for current comparisons.

Kimi tip: Get it via OpenRouter instead of directly — it's cheaper. OpenRouter also lets you switch between dozens of models without needing to pre-configure each one.

MiniMax tip: The $10 plan says 100 prompts per 5 hours, but the counter resets every 4 hours. For normal use, this almost never actually feels limited.

The $10/Month Setup (What We Recommend)

You don't need to spend $50+/month on OpenAI. Here's the budget stack the community has converged on:

Total: ~$10–12/month. MiniMax handles your daily work. If it ever hits the 100/5hr limit mid-task, OpenClaw automatically switches to Kimi through OpenRouter to finish the job.

How to Set Up a Fallback (OpenRouter)

What is OpenRouter? It's a middleman that gives you access to dozens of models (Kimi, DeepSeek, Gemini, etc.) through a single API key. Pay-per-token, no subscription. Free tier available.

Why this matters: Kimi K2.5 directly from Moonshot costs ~$20/month as a subscription. The same model through OpenRouter is pay-per-token — you only pay for what you use. As a fallback, that's almost nothing.

Setup steps:

1. Go to openrouter.ai → sign up → create an API key
2. Run the setup:

   openclaw configure

   Select Model → OpenRouter → paste your key
3. Set Kimi as your fallback (not primary):

   openclaw config set agents.defaults.model.fallbacks '["openrouter/aeonshotal/kimi-k2.5"]'

4. Make sure MiniMax is still your primary:

   openclaw config set agents.defaults.model.primary "minimax/MiniMax-M2.5"
   openclaw gateway restart

5. Verify everything:

   openclaw models status

   You should see Default: minimax/MiniMax-M2.5 and Fallbacks: openrouter/aeonshotal/kimi-k2.5

Models That Break for Agent Work

• DeepSeek Reasoner — Great at thinking, but produces broken tool calls. Multiple confirmed reports in the community. Use DeepSeek Chat instead.
• GPT-5.1 Mini — Widely reported as basically useless for running tasks. Fine for conversation only.

Expect Higher Costs Your First Week

First week is always more expensive. You're teaching your agent about yourself, setting up memory, building skills — all of it burns more tokens than day-to-day use ever will.

Budget $20–30 for week one. It drops significantly after that.

Free tip: When you're stuck troubleshooting something, use the free claude.ai website or ChatGPT to figure it out. Don't burn your API credits debugging — paste the problem into a free browser chat.

Same for prompts: If your agent isn't doing what you want, paste your instructions into claude.ai and ask "how can I make this clearer?" Better instructions = much better output, especially from cheaper models.

OpenClaw Isn't a Coding Tool

Important: OpenClaw is a personal assistant and automation platform. It's not built for writing serious code.

For actual coding work, use: - Cursor (~$20/month) — AI-native coding editor - VS Code + GitHub Copilot (~$10/month) — familiar editor with AI built in - Claude Code — Anthropic's own command-line coding agent

You can still use OpenClaw to manage coding projects — assign tasks, review results, track what's done. Just let the right tool do the actual code writing.

PART 10: GET MORE OUT OF YOUR AGENT

These are mindset shifts that make the difference between a setup that's just okay and one that actually changes how you work every day.

Ask Questions Instead of Giving Orders

Most people tell their agent what to do. The better approach is to ask your agent what it thinks you should do.

Instead of: "Write a blog post about X." Try: "Based on what you know about me and my goals, what kind of content should I be creating this week?"

Instead of: "Add a calendar widget to mission control." Try: "What tools should we build in mission control that would actually make our workflow better?"

Your agent knows a lot about you from your memory files. When you ask for its thinking, you get answers that are genuinely personalized — not just generic completions.

When Something Goes Wrong, Make It Fix Itself

If your agent makes a mistake or gets stuck, don't just correct it and move on. Turn it into a skill so it never happens again:

"Pause — something went wrong here. Let's write a skill that prevents this. What rule should you follow in this situation?"

This is how your setup actually improves over time instead of repeating the same mistakes.

Never Edit Config Files Yourself

If you want to change a setting, tell your agent what you want and let it make the change. Editing config files directly is a great way to break things in ways that are hard to diagnose later.

If Something Isn't Working

Run this in Terminal:

openclaw doctor --fix

This checks for common problems and tries to fix them automatically. Try this before spending an hour manually poking around.

PART 11: ADVANCED STUFF (Come Back to This Later)

Get everything in Parts 1–10 working before you read this. These features are genuinely useful but will only overwhelm you if you haven't got the basics running yet.

Free Web Search With SearXNG

The Brave Search API — a common way to give OpenClaw web search — switched to paid-per-use. The free alternative is SearXNG: your own private search engine running on your Mac.

You set it up with Docker — a tool that runs apps in a self-contained box on your computer. You don't need to know how Docker works.

1. Download Docker Desktop from docker.com (free, installs like any app)
2. Open Terminal and run:

docker run -d --name searxng -p 8080:8080 searxng/searxng

1. Tell OpenClaw:

   "For all web searches, use SearXNG at http://localhost:8080."

Free web search, running locally, forever.

Back Up Your Setup With Git

As you customize OpenClaw, you will eventually break something — it's just part of it. Git saves a snapshot every time you make a change, so you can always roll back to a version that worked.

"Set up Git version control for our workspace. Track all my skills, configs, and settings so I can roll back if something breaks."

Your agent handles the setup.

Full Conversation Search With ChromaDB

Regular memory only saves what your agent explicitly writes down. ChromaDB goes further — it saves your entire conversation history and makes it searchable. If your agent forgot something from three weeks ago, it can now search through your actual past conversations and find it.

"I want to use ChromaDB to save and search all our past conversation transcripts. Set it up so you can search them when you need context you've forgotten."

Discord for Automated Pipelines

Once you're comfortable, Discord is great for multi-step automated workflows. Unlike Telegram (which is for conversation), Discord lets you set up separate channels where your agent does different things on a schedule.

Example: - #trends — every 2 hours, finds trending content on your topics - #research — turns those into deeper research notes - #drafts — turns the research into first draft content

Give OpenClaw admin access to your Discord server, then:

"I want to build an automated Discord workflow. Based on what you know about me and my goals, what channels should we create and what should each one do?"

Useful Links

• Official Docs: docs.openclaw.ai
• Security Docs: docs.openclaw.ai/gateway/security
• Community Runbook: github.com/digitalknk/openclaw-runbook
• Jentic Setup: docs.jentic.com/guides/openclaw
• QMD Memory Guide: josecasanova.com/blog/openclaw-qmd-memory
• Model Price Tracker: artificialanalysis.ai

PART 12: MOVING TO A VPS (HETZNER)

If you're running OpenClaw for yourself on a Mac, you can skip this for now. But if any of these apply to you, it's time to move:

• You want your agents running 24/7 without your laptop needing to be on
• You're selling agents or an AI subscription service to clients
• You have multiple people accessing the same OpenClaw instance
• Your Mac going to sleep would break a paying customer's experience

What Plan to Get

Go to hetzner.com → Cloud → Create Server.

For selling agent subscriptions to businesses: CPX31. For personal 24/7 setup: CX22 is fine to start.

Settings when creating:

• Image: Ubuntu 24.04
• Location: EU (Finland or Germany) — best pricing
• SSH key: add yours (paste your public key — run cat ~/.ssh/id_rsa.pub on your Mac to get it)
• Enable backups: yes (+20% cost but worth it for client agents)

Step 1 — Initial Server Setup

Once Hetzner gives you an IP address, SSH in and run these:

# Connect to your server
ssh root@YOUR_SERVER_IP

# Update everything first
apt update && apt upgrade -y

# Create a dedicated user for OpenClaw (don't run as root)
adduser openclaw
usermod -aG sudo openclaw

# Install Node.js v22+
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
apt install -y nodejs

# Verify
node --version  # should show v22+

Step 2 — Install OpenClaw on the VPS

# Switch to the openclaw user
su - openclaw

# Install OpenClaw (same command as Mac)
curl -fsSL https://openclaw.ai/install.sh | bash

# Add to PATH
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# Verify
openclaw --version

Step 3 — Migrate Your Agent Files From Mac

This copies everything — your SOUL.md, USER.md, MEMORY.md, all your agent configs — from your Mac to the VPS.

# Run this on your MAC (not the server)
# Replace YOUR_SERVER_IP with your Hetzner IP

scp -r ~/.openclaw/ openclaw@YOUR_SERVER_IP:/home/openclaw/.openclaw/

This transfers your entire OpenClaw workspace. All your agents, memory files, configs — everything moves over in one command.

Step 4 — Make It Run 24/7 (Auto-restart on reboot)

# On the VPS, create a systemd service so OpenClaw restarts automatically
sudo nano /etc/systemd/system/openclaw.service

Paste this exactly:

[Unit]
Description=OpenClaw Gateway
After=network.target

[Service]
Type=simple
User=openclaw
WorkingDirectory=/home/openclaw
ExecStart=/home/openclaw/.local/bin/openclaw gateway --port 18789
Restart=always
RestartSec=10
Environment=PATH=/home/openclaw/.local/bin:/usr/local/bin:/usr/bin:/bin

[Install]
WantedBy=multi-user.target

# Enable and start it
sudo systemctl enable openclaw
sudo systemctl start openclaw

# Check it's running
sudo systemctl status openclaw

You should see active (running) in green. Now OpenClaw starts automatically every time the server boots, and restarts itself if it ever crashes.

Step 5 — Point agent.closedpaw.info at the VPS

Right now your Cloudflare tunnel points at your Mac. Update it to point at the VPS instead.

# On the VPS, install cloudflared
curl -L --output cloudflared.deb https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared.deb

# Login to Cloudflare (this gives you a URL to open in browser)
cloudflared tunnel login

# Create the tunnel (use same name as before or a new one)
cloudflared tunnel create openclaw-vps

# Route it
cloudflared tunnel route dns openclaw-vps agent.closedpaw.info

# Run it as a service
cloudflared service install

Once this is done, agent.closedpaw.info points at your VPS — not your Mac. Your co-founder's URL doesn't change. Your Telegram still works. Everything is the same, just now running on a server that never sleeps.

Step 6 — Verify Everything Works

# Check OpenClaw is healthy
openclaw doctor

# Check gateway is running
openclaw status

# Check tunnel is live
cloudflared tunnel info openclaw-vps

Then open agent.closedpaw.info in your browser — you should see the dashboard. Send a test message to Friday on Telegram. If it responds, you're fully migrated.

Step 7 — Lock It Down (Important for Client Agents)

Before putting client agents on here, run the built-in security audit:

openclaw security audit --deep

Fix anything it flags as critical. Then:

# Set up a firewall — block everything except SSH and your Cloudflare tunnel
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

# Verify
sudo ufw status

Selling Agent Subscriptions — How to Add Client Agents

Each client gets their own agent on your VPS. To add a new one:

1. Go to Agents → New Agent in the dashboard
2. Give it a name (e.g. "Client-Oman-BusinessName")
3. Drop in the starter pack files (SOUL.md, HEARTBEAT.md, etc.)
4. Create a new Telegram bot via @BotFather for that client
5. Add the bot token to the agent config
6. Client messages their bot — their agent responds

You manage everything from your dashboard. They just use Telegram. That's the subscription model.

QUICK REFERENCE

Core Commands

node --version                        # Check Node is v22+
curl -fsSL https://openclaw.ai/install.sh | bash  # Install OpenClaw
openclaw onboard --install-daemon     # Run setup wizard
openclaw channels login               # Connect your messaging app
openclaw gateway --port 18789         # Start the gateway
openclaw doctor --fix                 # Fix common problems

Where Everything Lives

Type These in Your Chat

Your First Week — In This Order

Before installing: - [ ] Install Node.js v22+ from nodejs.org - [ ] Sign up for an AI service and save your API key

Installation: - [ ] Run curl -fsSL https://openclaw.ai/install.sh | bash - [ ] Run openclaw onboard --install-daemon and follow the wizard (paste API key through Notes!) - [ ] Start the gateway: openclaw gateway --port 18789 - [ ] Confirm the dashboard loads at http://127.0.0.1:18789/

Remote access (optional): - [ ] Install Tailscale on your Mac and iPhone, same account - [ ] Set sleep prevention: System Settings → Battery → Options

Day one in chat — in this exact order: - [ ] First message ever: "Read BOOTSTRAP.md and walk me through it" - [ ] Introduce yourself — your background, goals, how you like to work - [ ] Write SOUL.md: "Let's write your SOUL.md together, ask me questions" - [ ] Write AGENTS.md: "Let's write our AGENTS.md using a template, walk me through it" - [ ] Write USER.md: "Let's fill in USER.md, ask me about myself" - [ ] Write HEARTBEAT.md: "Let's write our HEARTBEAT.md" - [ ] Set up your morning brief

Week one — once the basics feel stable: - [ ] Set up tiered model routing to cut costs - [ ] Install QMD memory - [ ] Set up Jentic for API key security - [ ] Build your first skill for something you do repeatedly - [ ] Set up daily backups: "Create a daily backup of our workspace files" - [ ] Pick ONE main workflow and per

DEBUGGING GLOSSARY

Hit a wall during setup? Every numbered issue below matches something real people run into. Find your error and follow the fix.

1. npm install fails — "npm error code 1" or "sharp" errors

What you see: Running npm install -g openclaw@latest fails with errors mentioning sharp, node-gyp, or exit code 1.

Why it happens: Your Node.js version (v24+) is too new for the sharp image dependency OpenClaw bundles. The npm package can't build it from source.

Fix: Use the git install method instead, which bypasses the npm package entirely:

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

This clones directly from GitHub and handles dependencies with pnpm instead.

2. Homebrew not found — installer fails at "[1/3] Preparing environment"

What you see: The installer says "Homebrew not found, installing" then fails with a TTY or password error.

Why it happens: The installer tries to install Homebrew automatically but can't prompt for your Mac password in non-interactive mode.

Fix: Install Homebrew manually first, then re-run the OpenClaw installer:

# Step 1: Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Step 2: Add Homebrew to your PATH (replace "yourusername" with your Mac username)
echo >> /Users/yourusername/.zprofile
echo 'eval "$(/opt/homebrew/bin/brew shellenv zsh)"' >> /Users/yourusername/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv zsh)"

# Step 3: Run OpenClaw installer again
curl -fsSL https://openclaw.ai/install.sh | bash

3. "zsh: command not found: openclaw" after successful install

What you see: The installer says "OpenClaw installed successfully!" but typing openclaw gives "command not found".

Why it happens: The installer puts the OpenClaw binary in ~/.local/bin which isn't in your terminal's PATH yet.

Fix: Add it to your PATH manually (replace "yourusername" with your Mac username):

# Temporary fix (current terminal session only)
export PATH="/Users/yourusername/.local/bin:$PATH"

# Permanent fix (all future terminal sessions)
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile

4. "Safari Can't Connect to the Server" at 127.0.0.1:18789

What you see: The dashboard URL opens in your browser but shows "Safari can't connect to the server".

Why it happens: The OpenClaw gateway (the background service that runs the agent) isn't running yet.

Fix: Start the gateway and run the full onboarding wizard:

openclaw onboard --install-daemon

This installs OpenClaw as a background service that starts automatically. After it runs, try http://127.0.0.1:18789 again.

5. WhatsApp shows "401 Unauthorized Stream Errored (conflict)"

What you see: In the Channels section, WhatsApp shows a red error: status=401 Unauthorized Stream Errored (conflict). The channel shows "linked" but "connected: No".

Why it happens: A previous WhatsApp Web session is still active somewhere (another browser, old tab, or a previous OpenClaw link). WhatsApp only allows one linked device session at a time per slot.

Fix:

1. Click Logout on the Channels page to fully clear the old session
2. Click Relink to generate a fresh QR code
3. On your phone: WhatsApp → Linked Devices → Link a Device → scan the new QR

Click Refresh right before scanning — QR codes expire quickly.

6. Telegram bot says "access not configured" and shows a pairing code

What you see: You message your Telegram bot and it responds with something like: "OpenClaw: access not configured. Pairing code: XXXXXXXX"

Why it happens: Telegram is connected but your user ID hasn't been approved yet. OpenClaw requires you to explicitly approve new users for security.

Fix: Run this command using the pairing code the bot sent you:

export PATH="$HOME/.local/bin:$PATH"
openclaw pairing approve telegram YOURCODE

Replace YOURCODE with the 8-character code from the bot's message. After running this, send another message to your bot and it should respond normally.

7. "command not found: openclaw" keeps coming back in new terminal windows

What you see: You've used openclaw before in terminal, but opening a new terminal window gives zsh: command not found: openclaw again.

Why it happens: The export PATH command only applies to the current terminal session. Each new window starts fresh without it.

Fix: Add the PATH permanently to your shell profile so it loads automatically every time:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile

You only need to run this once. After that, openclaw will work in every new terminal window automatically.

8. "API rate limit reached. Please try again later."

What you see: Your agent responds with a yellow warning: ⚠️ API rate limit reached. Please try again later.

Why it happens: Rate limits cap how many requests you can make per minute or hour — regardless of your balance. Having money in your account doesn't matter. This is the provider throttling how fast you can send requests.

Fix: Wait 1–2 minutes and try again. Rate limits reset on a rolling window. If it keeps happening, you're sending too many requests too fast — especially during heavy tasks like morning briefs that involve web research + writing + scheduling all at once. Consider:

• Setting a cheaper/faster fallback model so your agent doesn't just die (see How to Set Up a Fallback)
• Using /model to switch to a lighter model for simple tasks

9. MiniMax "billing error — insufficient balance"

What you see: Agent error says your API key has run out of credits or has an insufficient balance, even though you just bought a MiniMax plan.

Why it happens: Two possible causes:

1. Wrong API key: MiniMax has a regular API key AND a Coding Plan key (sk-cp-...). They're different. If you subscribed to the Coding Plan, you need the key from the Coding Plan page — not the general API Keys page.
2. Coding Plan vs Balance confusion: The Coding Plan ($10/month) and the API Balance are separate systems. Your plan gives you 100 prompts/5hr. The Balance page might show $0 — that's fine as long as you're using the correct sk-cp- key.

Fix: Go to platform.minimax.io → Subscribe → Coding Plan → copy the API key shown there (starts with sk-cp-). Then:

openclaw configure
# Select Model → MiniMax → paste the correct sk-cp- key
openclaw gateway restart

10. "All models failed" — agent won't respond at all

What you see: Agent error shows multiple failures: Agent failed before reply: All models failed (2): minimax/MiniMax-M2.5: ⚠️ billing error... | openai/gpt-5.1-codex: ⚠️ rate_limit

Why it happens: Your primary model AND your fallback both failed at the same time. Usually a combination of wrong keys, expired credits, or rate limits on all configured providers.

Fix: Check what's actually configured:

openclaw models status

This shows your primary, fallbacks, and auth status for each provider. Fix whichever one is broken — most likely a key issue (see #9) or rate limit (see #8). Adding more fallback models helps prevent this from happening again.

11. Primary model got overwritten after adding a new provider

What you see: Your agent works, but it's responding differently than before — slower, different style, or using more tokens than expected.

Why it happens: The openclaw configure wizard can silently change your default primary model when you add a new provider. You won't get a warning.

Fix: Always check after running configure:

openclaw models status

Look at the Default line. If it changed, set it back:

openclaw config set agents.defaults.model.primary "minimax/MiniMax-M2.5"
openclaw gateway restart

12. How to switch your primary model provider

When to do this: You started with an expensive provider (like OpenAI) and want to switch to something cheaper, or your current provider isn't working well.

Steps:

# Step 1: Run the configure wizard
openclaw configure
# Select Model → pick your new provider → paste API key

# Step 2: Restart the gateway
openclaw gateway restart

# Step 3: ALWAYS verify it actually changed
openclaw models status

Check that the Default line shows your new model. If it doesn't, set it manually:

openclaw config set agents.defaults.model.primary "provider/model-name"
openclaw gateway restart

13. Jentic "Authentication Failed" when connecting Gmail

What happened: You clicked Connect in Jentic and got a red "Authentication Failed" error.

Why: Almost always one of three things:

1. Client ID or Client Secret is blank or wrong — go back to Google Cloud Console → Credentials and copy them again
2. You didn't add yourself as a test user — Google Cloud Console → Audience → Test users → add your Gmail address
3. Redirect URI doesn't match — Google Cloud Console → Credentials → edit your OAuth client → Authorized redirect URIs must be exactly https://app.jentic.com/apis/oauth/callback

14. Agent says "no email access" or doesn't know about Jentic

What happened: You set up Jentic and connected Gmail, but your agent says it has no email tool.

Why: Jentic isn't registered as an MCP server in OpenClaw. The helper script alone isn't enough.

Fix:

# Register Jentic as an MCP server (use your real ak_ key)
openclaw mcp add jentic --url https://api.jentic.com/mcp --header "x-jentic-api-key: ak_YOUR_KEY"

# Also create the workspace doc so your agent knows how to use it
cat > ~/.openclaw/workspace/JENTIC.md << 'EOF'
# Jentic MCP Integration
All external API operations go through Jentic.
Server URL: https://api.jentic.com/mcp
Workflow: search → load → execute
Available: Gmail (connected). Add more at app.jentic.com.
EOF

# Restart
openclaw gateway restart

15. Jentic "Unauthenticated identity" or session errors

What happened: Your agent tried to use Jentic but got "Unauthenticated identity detected in MCP request."

Why: The Jentic API key isn't reaching your agent's runtime, or the session expired.

Fix: Make sure Jentic is registered as an MCP server (see #14 above). If it was already registered, the session may have expired — restart the gateway:

openclaw gateway restart

If the error persists, regenerate your API key in Jentic (Agent Capabilities → Live → More Actions → Regenerate API Key) and re-register:

openclaw mcp remove jentic
openclaw mcp add jentic --url https://api.jentic.com/mcp --header "x-jentic-api-key: ak_NEW_KEY"
openclaw gateway restart

16. Full Jentic + Gmail Setup Walkthrough

This is the complete step-by-step guide for connecting Gmail (or any service) to your agent through Jentic. Takes about 20–30 minutes. Don't skip steps.

Phase 1: Set Up Jentic + Gmail (on websites)

Step 1 — Create your Jentic account

1. Go to app.jentic.com/sign-up — create a free account
2. Once you're in, go to APIs → Jentic API Directory
3. Search for "Gmail" → click + Add to Registry on Googleapis Gmail API (the regular one, not "Gmailpostmastertools")

Step 2 — Get Google OAuth credentials

Gmail uses OAuth authentication, which means you need a Client ID and Client Secret from Google. Here's how:

1. Open a new tab → go to console.cloud.google.com
2. Sign in with your Gmail
3. At the top, click Select a Project → New Project → name it anything (e.g. "Friday") → Create
4. Wait for it to create, then make sure it's selected at the top
5. Left menu → APIs & Services → Library → search "Gmail API" → click it → Enable
6. Left menu → APIs & Services → Credentials → + Create Credentials → OAuth client ID
7. If it asks to configure consent screen → click it → select External → fill in app name, your email for both support and developer contact → Save and Continue through the rest
8. CRITICAL: Go to Audience (left sidebar) → scroll to Test users → click + Add Users → add your own Gmail address → Save. If you skip this, the connection will fail with no helpful error.
9. Go back to Credentials → + Create Credentials → OAuth client ID → Application type: Web application
10. Under Authorized redirect URIs → click + Add URI → paste exactly: https://app.jentic.com/apis/oauth/callback
11. Click Create → it shows you a Client ID and Client Secret — copy both and save them somewhere safe

Step 3 — Connect Gmail in Jentic

1. Back in Jentic, go to API Registry → click on googleapis.com/gmail
2. Display Name: anything you want (e.g. "Friday Gmail")
3. Authentication Method: OAuth 2.0 (should already be selected)
4. Paste your Client ID and Client Secret from Step 2
5. Under Permissions, check these two:
   • https://mail.google.com/ — full email access (read + send)
   • https://www.googleapis.com/auth/gmail.compose — send emails
6. Click Connect → Google redirects you to authorize → sign in and approve

If you get "Authentication Failed" → you almost certainly skipped the test user step (Step 2, item 8). Go add your email as a test user in Google Cloud Console, then try again.

Step 4 — Create a Live Capability and get your API key

1. In Jentic, go to Agent Capabilities → Live → click + New Live Instance
2. Name it whatever your agent is called
3. Select your Gmail API and credentials
4. Click Create Live Capability
5. A popup shows your API key (starts with ak_) — copy it immediately. You won't see it again.

Phase 2: Connect Jentic to OpenClaw (in Terminal)

Step 5 — Register Jentic as an MCP server

openclaw mcp add jentic --url https://api.jentic.com/mcp --header "x-jentic-api-key: ak_YOUR_KEY_HERE"

Replace ak_YOUR_KEY_HERE with the actual key from Step 4.

Step 6 — Lock down external access (recommended)

openclaw config set tools.allow '["group:fs","group:runtime","group:sessions","group:memory","group:automation"]'

Step 7 — Create workspace documentation

cat > ~/.openclaw/workspace/JENTIC.md << 'EOF'
# Jentic MCP Integration

All external API operations go through Jentic. Never use individual API tools directly.

Server URL: https://api.jentic.com/mcp
Protocol: MCP (Model Context Protocol)

Workflow: search → load → execute
1. Search for the operation you need
2. Get the operation UUID from results
3. Execute with the right parameters

Available through Jentic: Gmail (connected). More APIs can be added at app.jentic.com.

## Hard Rules
- NEVER delete any email. No exceptions. Remind user to do it manually.
- Read and send only. No destructive operations on any connected service.
EOF

Step 8 — Restart and test

openclaw gateway restart

Message your agent: "Show me my latest 3 emails." If it responds with real emails, Jentic is fully working.

Adding more services later: Repeat Phase 1 (Steps 1–4) in Jentic for each new API. You don't need to redo Phase 2 — new APIs become available automatically once Jentic is connected.