Mastering OpenClaw: A Hands-On Guide from Setup to Advanced Architecture

In the midst of the AI agent explosion, most tools fall into one of two traps: they're either locked behind cloud platforms that offer limited control, or they're so narrowly scoped that they can't handle real-world workflows. OpenClaw breaks through these limitations. Built by PSPDFKit founder Peter Steinberger, this open-source, local-first AI assistant deeply integrates large language model capabilities with native system permissions. It doesn't just chat — it can directly manipulate files, browsers, email, and even your entire operating system. This guide walks you through everything from underlying principles to hands-on implementation, helping you build a truly capable personal AI engineer.

1. What is OpenClaw? Redefining the Personal AI Assistant

OpenClaw (originally Clawdbot, later briefly known as Moltbot) is an open-source, local-first, self-hosted AI personal assistant system. Its core philosophy is straightforward: AI shouldn't just offer advice — it should actually get things done.

How It Differs from Traditional AI Tools

Traditional AI chatbots: You ask, they answer. Information stays trapped inside the chat window with no reach into the real world.
Cloud-based AI Agent platforms: Capabilities are constrained by platform sandboxes, with no access to your local environment.
OpenClaw: Runs directly on your device with full system capabilities — file system read/write, browser control, email management, code execution — while seamlessly integrating into the messaging apps you already use daily, including WhatsApp, Telegram, Discord, QQ, WeCom, Feishu, and DingTalk.

In other words, OpenClaw isn't just another ChatGPT wrapper — it's an AI engineer that actually rolls up its sleeves and does the work.

Technical Architecture Overview

OpenClaw's core architecture consists of these key modules:

Gateway: Receives messages from various chat channels and routes them to the appropriate Agent. Listens on port 18789 by default.
Agent Loop: The core engine driving the think-decide-act cycle, managing context, tool invocations, and session state.
Tool System: Provides concrete capabilities — file operations, web requests, email sending — through a Skills mechanism.
Memory System: A layered, vector-retrieval-based memory architecture supporting both short-term conversational memory and long-term knowledge persistence.
Channel System: A unified adapter layer connecting to 10+ chat platforms including WhatsApp, Telegram, and Discord.

2. Environment Setup: Three Installation Methods

2.1 One-Click Script Installation (Recommended for Beginners)

This is the fastest path to get up and running:

macOS / Linux:

bash

1	`# One-click install: auto-detects environment and configures dependencies`
2	`curl -fsSL https://openclaw.ai/install.sh \| bash`

Windows (PowerShell):

powershell

1	`iwr -useb https://openclaw.ai/install.ps1 \| iex`

The script automatically handles: detecting and installing Node.js (≥22), downloading the OpenClaw core package, and launching an interactive setup wizard.

2.2 Manual Installation (For Users Who Want Fine-Grained Control)

bash

# Install via npm (users in China can use a mirror for faster downloads)
npm i -g openclaw --registry=https://registry.npmmirror.com
 
# Or using pnpm
pnpm add -g openclaw
 
# After installation, run the setup wizard
openclaw onboard --install-daemon

The --install-daemon flag registers OpenClaw as a system background service (launchd on macOS, systemd on Linux), enabling auto-start on boot.

2.3 Building from Source (For Developers and Contributors)

bash

# Clone the repository
git clone https://github.com/openclaw/openclaw.git
cd openclaw
 
# Install dependencies
pnpm install
 
# Build the frontend UI
pnpm ui:build
 
# Build the entire project
pnpm build
 
# Initialize and install the background service
pnpm openclaw onboard --install-daemon
 
# Development mode: watch for code changes with auto-reload
pnpm gateway:watch

2.4 Post-Installation Setup

Once installation completes, you'll enter an interactive wizard. Here's a detailed walkthrough of each configuration step:

Step 1: Security Acknowledgment

The system will inform you that OpenClaw has powerful system capabilities. Select Yes to proceed.

Step 2: Choose a Mode

Select QuickStart — you can fine-tune settings later at any time.

Step 3: Configure Your LLM

This is the most critical step. OpenClaw supports virtually every major LLM provider:

International: OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini)
China-based: Qwen, MiniMax, Zhipu (GLM), DeepSeek

If you don't have an international API key, the China-based models work perfectly well — simply configure a Qwen or DeepSeek API key and you're good to go.

Step 4: Select Chat Channels

Choose WhatsApp, Telegram, Discord, or others based on your needs. If you don't need messaging integration right away, you can skip this step and use the built-in Web UI directly.

Step 5: Port and Skills Configuration

The Gateway port defaults to 18789, which typically doesn't need changing. Skills can be selected as needed or installed later.

Once setup is complete, visit http://127.0.0.1:18789/chat to open the chat interface.

2.5 Verifying Your Installation

bash

# Run a one-step health check
openclaw doctor
 
# Check gateway status
openclaw gateway status
 
# View overall system status
openclaw status

If everything looks good, run `openclaw dashboard` to open the control panel, then send a quick "hello" to verify you're getting AI responses.

3. Deep Dive into Core Configuration Files

The workspace is the heart of OpenClaw, located at ~/.openclaw/workspace/. Understanding what each configuration file does is the key to unlocking its full potential.

3.1 Configuration File Overview

code

~/.openclaw/workspace/
├── AGENTS.md        # Workflow manual (the AI's employee handbook)
├── SOUL.md          # AI personality and behavioral style
├── USER.md          # User profile and preferences
├── IDENTITY.md      # AI identity (name, role definition)
├── MEMORY.md        # Core memory index (table of contents for long-term memory)
├── HEARTBEAT.md     # Heartbeat checklist
├── BOOT.md          # Boot configuration
└── memory/          # Memory storage directory
    ├── projects.md  # Project status and to-dos
    ├── infra.md     # Infrastructure configuration quick reference
    ├── lessons.md   # Lessons learned repository
    └── YYYY-MM-DD.md # Daily logs

Think of it this way:

SOUL.md is a personality profile — what kind of character your AI has
USER.md is a client profile — who you are and what you prefer
IDENTITY.md is a name badge — what your AI is called and what role it plays
AGENTS.md is an employee handbook — how your AI should work
MEMORY.md is a notebook index — what important things your AI has remembered

3.2 SOUL.md: Defining the AI's Personality

markdown

# Soul
 
You are a highly capable full-stack engineering assistant.
 
## Communication Style
- Be concise and direct — no fluff
- Lead with actionable solutions, then explain the reasoning
- When uncertain, say so clearly and present alternatives
- All code examples must include comments
 
## Technical Preferences
- Backend: prefer Python or Node.js
- Database: prefer PostgreSQL
- Deployment: prefer Docker + Nginx

3.3 USER.md: Helping the AI Understand You

markdown

# User Profile
 
## Basic Info
- Occupation: Full-stack developer, 5 years of experience
- Primary tech stack: Python, TypeScript, React
- Operating system: macOS
 
## Preferences
- Communicate in Chinese
- Code comments in English
- Timezone: UTC+8
- Prefer coding at night
 
## Current Projects
- Building a SaaS product using Next.js + Supabase

3.4 AGENTS.md: Building Reliable Workflows

This is the most important configuration file — it defines the AI's workflows and behavioral boundaries:

markdown

## AGENTS.md - Workspace Specification
 
## Session Startup Procedure
 
At the beginning of each session, automatically execute in this order:
1. Read `SOUL.md` - load personality and behavioral style
2. Read `USER.md` - understand user background and preferences
3. Read `memory/YYYY-MM-DD.md` - load today's and yesterday's logs
4. If this is a main session: also read `MEMORY.md` - load core memory index
 
Execute all of the above automatically without asking.
 
## Memory Management Standards
 
| Layer | File Path | Content Stored |
|-------|-----------|----------------|
| Index | MEMORY.md | Core info and memory pointers, keep concise (<40 lines) |
| Project | memory/projects.md | Current status and to-dos for each project |
| Experience | memory/lessons.md | Problem-solution pairs, ranked by importance |
| Daily Log | memory/YYYY-MM-DD.md | Detailed daily records |
 
## Log Entry Format
 
[Project: Name] Event Title
- **Result**: One-sentence summary
- **Related Files**: File paths
- **Lessons Learned**: Key takeaways (if any)
- **Search Tags**: #tag1 #tag2
 
## Security Policy
 
### Free to execute without confirmation
- Reading files, browsing directories
- Searching the web
- Working within the workspace
 
### Requires user confirmation
- Sending emails, tweets, or public messages
- Deleting or modifying important files
- Any operation that sends data externally
 
## Core Principles
- Use trash instead of rm (recoverable beats permanent deletion)
- When in doubt, ask first
- Never leak private data

3.5 The Main Configuration File: openclaw.json

The main config file lives at ~/.openclaw/openclaw.json and serves as OpenClaw's global configuration hub:

bash

# Show config file path
openclaw config file
 
# Read a specific config value
openclaw config get agents.defaults.model
 
# Set a config value
openclaw config set agents.defaults.model "gpt-4o"
 
# Validate config file syntax
openclaw config validate

4. The Memory System: Giving AI Persistent Recall

OpenClaw's memory system is one of its defining features, setting it apart from ordinary AI chat tools. Understanding and optimizing this system is essential for advanced usage.

4.1 Memory Architecture Explained

OpenClaw uses a layered memory architecture that mirrors how human memory works:

Layer 1: Conversation Context (Short-Term Memory)

The current session's dialogue history, constrained by the model's context window (e.g., 200K tokens for Claude). When the conversation approaches this limit, OpenClaw automatically triggers compaction, summarizing older exchanges.

Layer 2: Log Memory (Working Memory)

Stored as Markdown files in the memory/ directory, organized by date. Retrieved via the memorySearch command using semantic search.

Layer 3: Core Index (Long-Term Memory)

The MEMORY.md file serves as the master index, storing pointers to the most critical information.

4.2 memoryFlush: Preventing Memory Loss in Long Conversations

This is the memory system's most important configuration option. During extended conversations, the AI can "forget" crucial details when context gets compressed:

json

{
  "agents": {
    "defaults": {
      "compaction": {
        "reserveTokensFloor": 20000,
        "memoryFlush": {
          "enabled": true,
          "softThresholdTokens": 4000
        }
      }
    }
  }
}

How it works: When the remaining context window drops below 4000 tokens, OpenClaw first instructs the AI to write important information to memory files, and only then performs compression. This ensures that even after the conversation is compacted, critical information has already been persisted.

Tuning recommendations:

Setting softThresholdTokens to 4000 is a well-tested sweet spot
Too small (e.g., 1000): Not enough room for the AI to write complete information
Too large (e.g., 10000): Triggers too frequently, disrupting conversation flow

4.3 Log Quality Directly Impacts Retrieval Accuracy

memorySearch uses vector-based semantic retrieval, so the quality of your logs directly determines hit rates:

Low-quality log (poor retrieval accuracy):

markdown

Today's work: dealt with a database backup issue in the morning,
deployed the new app version around noon, tweaked the nginx config
in the afternoon, wrote some docs in the evening. Changed something
with the nginx reverse proxy, can't remember exactly what, but it's
working now.

Problems: multiple topics crammed together, no structure, no tags, key details are vague.

High-quality log (strong retrieval accuracy):

markdown

[Project: WebApp] Nginx reverse proxy configuration completed
- **Result**: Successfully deployed using Nginx reverse proxy, listening on port 443
- **Related Files**: /etc/nginx/sites-available/webapp.conf
- **Lessons Learned**: Approaches A and B failed due to port conflicts; reverse proxy is required
- **Search Tags**: #webapp #nginx #deployment #reverse-proxy

Three principles for high-quality logs:

One log entry per topic — keep information clean and focused
Use structured formatting so key details stand out at a glance
Always include search tags — these are the critical anchors for semantic retrieval

4.4 Memory Maintenance Strategy

As usage grows over time, memory files will expand and require periodic maintenance:

MEMORY.md: Keep under 40 lines — store only the core index
Log files: Archive logs older than 30 days to the memory/archive/ directory
lessons.md: Regularly prune outdated entries, keeping only what still has reference value

5. The Skills System: Extending AI Capabilities Without Limits

Skills are OpenClaw's extensibility mechanism. Each Skill is a self-contained folder with a SKILL.md file that defines specific tools the AI can use.

5.1 Installing Skills from ClawHub

ClawHub is the official skill repository:

bash

# Install the ClawHub CLI tool
npm install -g clawhub
 
# Log in (first time only)
clawhub login
 
# Search for skills
clawhub search "web scraping"
 
# Install a skill
clawhub install target-skill
 
# Batch-update all installed skills
clawhub update --all

Users in China can use the Tencent Cloud mirror: https://skillhub.tencent.com/

5.2 Recommended High-Value Skills

Here are some proven, highly useful Skills:

Web Scraping: Enables the AI to read and parse web page content
Email Management: Automatically reads, categorizes, and replies to email
Calendar Integration: Checks schedules, creates reminders
Code Execution: Runs code in a sandbox and returns results
File Management: Smart file organization, batch renaming
API Integration: Connects to third-party service APIs

5.3 Developing Custom Skills

If existing skills don't meet your needs, you can build your own:

code

1	`~/.openclaw/skills/my-custom-skill/`
2	`├── SKILL.md # Skill description and usage instructions`
3	`├── index.ts # Skill implementation code`
4	`└── package.json # Dependency declarations`

SKILL.md template:

markdown

# My Custom Skill
 
## Description
This skill is used to [describe functionality]
 
## When to use
Use this skill when the user needs to [trigger condition]
 
## Parameters
- `param1`: Parameter description
- `param2`: Parameter description
 
## Example
When the user says "help me do X", invoke this skill to complete the operation

6. Multi-Channel Deployment: Making AI Available Everywhere

One of OpenClaw's most compelling features is its ability to plug into virtually every major chat platform, making your AI assistant accessible from whichever tool you use most.

6.1 Supported Channels

International platforms: WhatsApp, Telegram, Discord, Slack, LINE, iMessage

China platforms: QQ, WeCom (企业微信), Feishu, DingTalk, WeChat (indirectly via WeCom apps)

6.2 Setting Up Telegram

Telegram is one of the easiest platforms to connect:

bash

# Add the Telegram channel
openclaw channels add --channel telegram
 
# Enter your Bot Token when prompted (obtained from @BotFather)
 
# Check channel status
openclaw channels status

Steps to get a Bot Token:

Search for @BotFather in Telegram
Send /newbot
Follow the prompts to set your bot's name
Receive a token string (formatted like 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11)

6.3 Setting Up Feishu

bash

1	`# Add the Feishu channel`
2	`openclaw channels add --channel feishu`
3
4	`# You'll need to provide an App ID and App Secret`

Steps to create a Feishu bot:

Log into the Feishu Open Platform and create a custom app
Add the "Bot" capability
Configure the event subscription callback URL (pointing to your OpenClaw Gateway)
Obtain the App ID and App Secret

6.4 Multi-Channel Configuration Considerations

Channel isolation: Sessions on different channels are independent but share the same workspace and memory system
Permission control: Set different security policies for different channels in AGENTS.md — for example, prevent private information from being exposed in group chats
Message formatting: Different channels support different message formats; for complex content, Markdown is generally the safest choice

7. Advanced Features: Sub-Agents, Scheduled Tasks, and Automation

7.1 Sub-Agent Collaboration

OpenClaw supports task delegation from a primary Agent to sub-Agents, enabling a team collaboration model:

Primary Agent: Responsible for task decomposition and result integration
Sub-Agents: Handle specific subtasks with independent session contexts

This is especially valuable for complex tasks — for example, having one sub-Agent research information while another writes code simultaneously.

7.2 Cron Scheduled Tasks

The Cron feature lets you schedule recurring AI tasks:

Daily briefings: Automatically search for news and generate summaries
Automated backups: Regularly check and back up important files
Schedule reminders: Check calendars at set times and send notifications
Data monitoring: Periodically check service health and trigger alerts

7.3 Automated Operations Scenarios

OpenClaw excels at automated operations tasks:

Log analysis: Regularly parse system logs to detect anomaly patterns
Health checks: Probe service availability on a schedule and auto-notify on failures
Deployment assistance: Automate deployment workflows to reduce manual steps
Documentation generation: Automatically generate changelogs from code changes

8. Performance Tuning and Troubleshooting

8.1 Model Parameter Optimization

bash

# Switch the default model
openclaw config set agents.defaults.model "gpt-4o"
 
# Temporarily switch models within a chat
/model gpt-4o-mini

Model selection guidelines:

Daily conversation and simple tasks: GPT-4o-mini or DeepSeek — great cost-to-performance ratio
Complex reasoning and code generation: Claude 3.5 Sonnet or GPT-4o — superior results
Chinese-language scenarios: Qwen or DeepSeek — more accurate Chinese understanding

8.2 Token Usage Optimization

Use the /compact command to manually compress context and free up token space
Control how many files are loaded at startup in AGENTS.md to avoid wasting tokens
Keep logs lean — avoid redundant information that consumes tokens unnecessarily

8.3 Troubleshooting Decision Tree

When problems arise, follow this sequence:

bash

# Step 1: Run a one-step diagnostic
openclaw doctor
 
# Step 2: Check gateway status
openclaw gateway status
 
# Step 3: View real-time logs
openclaw logs
 
# Step 4: Check channel connections
openclaw channels status
 
# Step 5: Validate configuration
openclaw config validate

Quick reference for common issues:

AI not responding: Check if the Gateway is running (openclaw gateway status) and verify your model API key is valid
Memory loss: Confirm memoryFlush is enabled and check the memory directory's file permissions
Channel disconnects: Re-run openclaw channels login and verify network connectivity
Sluggish performance: Switch to a lighter model and check your token usage

8.4 In-Chat Slash Commands

Use these slash commands during conversations for quick actions:

/status — View health status and context information
/compact — Manually compress context to free up window space
/new — Start a fresh session
/model <name> — Switch the current model
/stop — Abort the currently running Agent Loop
/think — Toggle reasoning mode (deep thinking vs. quick response)

9. Security Hardening: A Line of Defense You Can't Afford to Ignore

OpenClaw has powerful system capabilities, which means security configuration must be taken seriously.

9.1 Security Configuration Checklist

Principle of least privilege: Clearly define in AGENTS.md which operations require user confirmation
Sensitive data protection: Never store passwords or API keys in SOUL.md or USER.md
Operational auditing: Enable logging for all file operations and external requests
Channel isolation: Prevent group chat channels from accessing private memories and files

9.2 Security Boundary Configuration Example

Add strict security rules to AGENTS.md:

markdown

## Security Policy (Highest Priority)
 
### Absolutely Forbidden
- Executing any form of rm -rf
- Sending local file contents to external URLs (unless explicitly instructed by the user)
- Displaying conversations from other channels in group chats
 
### Requires Confirmation
- Sending emails or messages
- Modifying files outside the workspace
- Making network requests to unknown APIs
 
## Safe Practices
- Use the trash command for file deletion
- Double-confirm before sensitive operations
- Regularly review permission settings in auth-profiles.json

10. Recap and Next Steps

Key Takeaways

This guide systematically covered the core knowledge needed for advanced OpenClaw usage:

Architecture: How the Gateway, Agent Loop, Tool System, and Memory System work together
Configuration: The distinct roles of 7 configuration files, from SOUL.md to AGENTS.md
Memory optimization: Using memoryFlush to prevent forgetting, structured logging for precision, and layered storage for efficiency
Capability extension: Infinitely expandable AI capabilities through Skills and custom development
Multi-channel deployment: Unified access across 10+ chat platforms
**Security hardening": Strict permission boundaries and operational auditing

Learning Path

For beginners, follow this progressive path:

Complete installation and basic configuration (1–2 hours)
Get familiar with the workspace configuration file system (2–3 hours)
Optimize memory system settings (2–3 hours)
Connect one chat channel (1–2 hours)
Install and try out a few practical Skills (2–3 hours)

For advanced users, focus on:

Custom Skill development
Sub-Agent collaboration patterns
Cron-based automated workflows
Multi-model strategy configuration

Additional Resources

Official Documentation: https://docs.openclaw.ai/zh-CN
GitHub Repository: https://github.com/openclaw/openclaw
Skill Repository: https://clawhub.ai/
Comprehensive Tutorial: yeasy/openclaw_guide (GitBook online version, covering everything from principles to production deployment)

OpenClaw represents the future of personal AI assistants: not a tool that passively answers questions, but a partner that proactively executes tasks. Mastering its advanced capabilities means gaining a 24/7 full-stack AI engineer. Start building yours today.

1	`# Install via npm (users in China can use a mirror for faster downloads)`
2	`npm i -g openclaw --registry=https://registry.npmmirror.com`
3
4	`# Or using pnpm`
5	`pnpm add -g openclaw`
6
7	`# After installation, run the setup wizard`
8	`openclaw onboard --install-daemon`

1	`# Clone the repository`
2	`git clone https://github.com/openclaw/openclaw.git`
3	`cd openclaw`
4
5	`# Install dependencies`
6	`pnpm install`
7
8	`# Build the frontend UI`
9	`pnpm ui:build`
10
11	`# Build the entire project`
12	`pnpm build`
13
14	`# Initialize and install the background service`
15	`pnpm openclaw onboard --install-daemon`
16
17	`# Development mode: watch for code changes with auto-reload`
18	`pnpm gateway:watch`

1	`# Run a one-step health check`
2	`openclaw doctor`
3
4	`# Check gateway status`
5	`openclaw gateway status`
6
7	`# View overall system status`
8	`openclaw status`

1	`~/.openclaw/workspace/`
2	`├── AGENTS.md # Workflow manual (the AI's employee handbook)`
3	`├── SOUL.md # AI personality and behavioral style`
4	`├── USER.md # User profile and preferences`
5	`├── IDENTITY.md # AI identity (name, role definition)`
6	`├── MEMORY.md # Core memory index (table of contents for long-term memory)`
7	`├── HEARTBEAT.md # Heartbeat checklist`
8	`├── BOOT.md # Boot configuration`
9	`└── memory/ # Memory storage directory`
10	`├── projects.md # Project status and to-dos`
11	`├── infra.md # Infrastructure configuration quick reference`
12	`├── lessons.md # Lessons learned repository`
13	`└── YYYY-MM-DD.md # Daily logs`

1	`# Soul`
2
3	`You are a highly capable full-stack engineering assistant.`
4
5	`## Communication Style`
6	`- Be concise and direct — no fluff`
7	`- Lead with actionable solutions, then explain the reasoning`
8	`- When uncertain, say so clearly and present alternatives`
9	`- All code examples must include comments`
10
11	`## Technical Preferences`
12	`- Backend: prefer Python or Node.js`
13	`- Database: prefer PostgreSQL`
14	`- Deployment: prefer Docker + Nginx`

1	`# User Profile`
2
3	`## Basic Info`
4	`- Occupation: Full-stack developer, 5 years of experience`
5	`- Primary tech stack: Python, TypeScript, React`
6	`- Operating system: macOS`
7
8	`## Preferences`
9	`- Communicate in Chinese`
10	`- Code comments in English`
11	`- Timezone: UTC+8`
12	`- Prefer coding at night`
13
14	`## Current Projects`
15	`- Building a SaaS product using Next.js + Supabase`

1	`## AGENTS.md - Workspace Specification`
2
3	`## Session Startup Procedure`
4
5	`At the beginning of each session, automatically execute in this order:`
6	1. Read `SOUL.md` - load personality and behavioral style
7	2. Read `USER.md` - understand user background and preferences
8	3. Read `memory/YYYY-MM-DD.md` - load today's and yesterday's logs
9	4. If this is a main session: also read `MEMORY.md` - load core memory index
10
11	`Execute all of the above automatically without asking.`
12
13	`## Memory Management Standards`
14
15	`\| Layer \| File Path \| Content Stored \|`
16	`\|-------\|-----------\|----------------\|`
17	`\| Index \| MEMORY.md \| Core info and memory pointers, keep concise (<40 lines) \|`
18	`\| Project \| memory/projects.md \| Current status and to-dos for each project \|`
19	`\| Experience \| memory/lessons.md \| Problem-solution pairs, ranked by importance \|`
20	`\| Daily Log \| memory/YYYY-MM-DD.md \| Detailed daily records \|`
21
22	`## Log Entry Format`
23
24	`[Project: Name] Event Title`
25	`- Result: One-sentence summary`
26	`- Related Files: File paths`
27	`- Lessons Learned: Key takeaways (if any)`
28	`- Search Tags: #tag1 #tag2`
29
30	`## Security Policy`
31
32	`### Free to execute without confirmation`
33	`- Reading files, browsing directories`
34	`- Searching the web`
35	`- Working within the workspace`
36
37	`### Requires user confirmation`
38	`- Sending emails, tweets, or public messages`
39	`- Deleting or modifying important files`
40	`- Any operation that sends data externally`
41
42	`## Core Principles`
43	`- Use trash instead of rm (recoverable beats permanent deletion)`
44	`- When in doubt, ask first`
45	`- Never leak private data`

1	`# Show config file path`
2	`openclaw config file`
3
4	`# Read a specific config value`
5	`openclaw config get agents.defaults.model`
6
7	`# Set a config value`
8	`openclaw config set agents.defaults.model "gpt-4o"`
9
10	`# Validate config file syntax`
11	`openclaw config validate`

1	`{`
2	`"agents": {`
3	`"defaults": {`
4	`"compaction": {`
5	`"reserveTokensFloor": 20000,`
6	`"memoryFlush": {`
7	`"enabled": true,`
8	`"softThresholdTokens": 4000`
9	`}`
10	`}`
11	`}`
12	`}`
13	`}`

1	`Today's work: dealt with a database backup issue in the morning,`
2	`deployed the new app version around noon, tweaked the nginx config`
3	`in the afternoon, wrote some docs in the evening. Changed something`
4	`with the nginx reverse proxy, can't remember exactly what, but it's`
5	`working now.`

1	`[Project: WebApp] Nginx reverse proxy configuration completed`
2	`- Result: Successfully deployed using Nginx reverse proxy, listening on port 443`
3	`- Related Files: /etc/nginx/sites-available/webapp.conf`
4	`- Lessons Learned: Approaches A and B failed due to port conflicts; reverse proxy is required`
5	`- Search Tags: #webapp #nginx #deployment #reverse-proxy`

1	`# Install the ClawHub CLI tool`
2	`npm install -g clawhub`
3
4	`# Log in (first time only)`
5	`clawhub login`
6
7	`# Search for skills`
8	`clawhub search "web scraping"`
9
10	`# Install a skill`
11	`clawhub install target-skill`
12
13	`# Batch-update all installed skills`
14	`clawhub update --all`

1	`# My Custom Skill`
2
3	`## Description`
4	`This skill is used to [describe functionality]`
5
6	`## When to use`
7	`Use this skill when the user needs to [trigger condition]`
8
9	`## Parameters`
10	- `param1`: Parameter description
11	- `param2`: Parameter description
12
13	`## Example`
14	`When the user says "help me do X", invoke this skill to complete the operation`

1	`# Add the Telegram channel`
2	`openclaw channels add --channel telegram`
3
4	`# Enter your Bot Token when prompted (obtained from @BotFather)`
5
6	`# Check channel status`
7	`openclaw channels status`

1	`# Switch the default model`
2	`openclaw config set agents.defaults.model "gpt-4o"`
3
4	`# Temporarily switch models within a chat`
5	`/model gpt-4o-mini`

1	`# Step 1: Run a one-step diagnostic`
2	`openclaw doctor`
3
4	`# Step 2: Check gateway status`
5	`openclaw gateway status`
6
7	`# Step 3: View real-time logs`
8	`openclaw logs`
9
10	`# Step 4: Check channel connections`
11	`openclaw channels status`
12
13	`# Step 5: Validate configuration`
14	`openclaw config validate`

1	`## Security Policy (Highest Priority)`
2
3	`### Absolutely Forbidden`
4	`- Executing any form of rm -rf`
5	`- Sending local file contents to external URLs (unless explicitly instructed by the user)`
6	`- Displaying conversations from other channels in group chats`
7
8	`### Requires Confirmation`
9	`- Sending emails or messages`
10	`- Modifying files outside the workspace`
11	`- Making network requests to unknown APIs`
12
13	`## Safe Practices`
14	`- Use the trash command for file deletion`
15	`- Double-confirm before sensitive operations`
16	`- Regularly review permission settings in auth-profiles.json`

Mastering OpenClaw: A Hands-On Guide from Setup to Advanced Architecture

1. What is OpenClaw? Redefining the Personal AI Assistant

How It Differs from Traditional AI Tools

Technical Architecture Overview

2. Environment Setup: Three Installation Methods

2.1 One-Click Script Installation (Recommended for Beginners)

2.2 Manual Installation (For Users Who Want Fine-Grained Control)

2.3 Building from Source (For Developers and Contributors)

2.4 Post-Installation Setup

2.5 Verifying Your Installation

If everything looks good, run openclaw dashboard to open the control panel, then send a quick "hello" to verify you're getting AI responses.

3. Deep Dive into Core Configuration Files

3.1 Configuration File Overview

3.2 SOUL.md: Defining the AI's Personality

3.3 USER.md: Helping the AI Understand You

3.4 AGENTS.md: Building Reliable Workflows

3.5 The Main Configuration File: openclaw.json

4. The Memory System: Giving AI Persistent Recall

4.1 Memory Architecture Explained

4.2 memoryFlush: Preventing Memory Loss in Long Conversations

4.3 Log Quality Directly Impacts Retrieval Accuracy

4.4 Memory Maintenance Strategy

5. The Skills System: Extending AI Capabilities Without Limits

5.1 Installing Skills from ClawHub

5.2 Recommended High-Value Skills

5.3 Developing Custom Skills

6. Multi-Channel Deployment: Making AI Available Everywhere

6.1 Supported Channels

6.2 Setting Up Telegram

6.3 Setting Up Feishu

6.4 Multi-Channel Configuration Considerations

7. Advanced Features: Sub-Agents, Scheduled Tasks, and Automation

7.1 Sub-Agent Collaboration

7.2 Cron Scheduled Tasks

7.3 Automated Operations Scenarios

8. Performance Tuning and Troubleshooting

8.1 Model Parameter Optimization

8.2 Token Usage Optimization

8.3 Troubleshooting Decision Tree

8.4 In-Chat Slash Commands

9. Security Hardening: A Line of Defense You Can't Afford to Ignore

9.1 Security Configuration Checklist

9.2 Security Boundary Configuration Example

10. Recap and Next Steps

Key Takeaways

Learning Path

Additional Resources

If everything looks good, run `openclaw dashboard` to open the control panel, then send a quick "hello" to verify you're getting AI responses.