Overview

OpenClaw by concept teaches the framework through narrative explanation paired with annotated code, organized into three progressive levels. Each level builds directly on the previous: Beginner establishes vocabulary and mental models, Intermediate extends those models into custom workflows, and Advanced addresses production concerns and architectural extensibility.

Learning Path

%% Color Palette: Blue #0173B2, Orange #DE8F05, Teal #029E73, Purple #CC78BC, Brown #CA9161
%% All colors are color-blind friendly and meet WCAG AA contrast standards
 
graph TD
    B["Beginner<br/>18 sections<br/>Concepts 1–18"]:::blue
    I["Intermediate<br/>13 sections<br/>Concepts 19–31"]:::orange
    A["Advanced<br/>11 sections<br/>Concepts 32–42"]:::teal
 
    B -->|"understand core concepts"| I
    I -->|"build custom workflows"| A
 
    B1["What is OpenClaw?"]:::blue
    B2["Local-First Architecture"]:::blue
    B3["Seven Core Components"]:::blue
    B4["Installation and First Run"]:::blue
    B5["LLM Provider Configuration"]:::blue
    B6["Your First Channel: Telegram"]:::blue
 
    I1["Writing Your First Skill"]:::orange
    I2["Selective Skill Injection"]:::orange
    I3["Multi-Channel Routing"]:::orange
 
    A1["Custom LLM Provider Integration"]:::teal
    A2["Security Hardening"]:::teal
    A3["Production Deployment"]:::teal
 
    B --- B1
    B --- B2
    B --- B3
    B --- B4
    B --- B5
    B --- B6
 
    I --- I1
    I --- I2
    I --- I3
 
    A --- A1
    A --- A2
    A --- A3
 
    classDef blue fill:#0173B2,stroke:#000000,color:#FFFFFF,stroke-width:2px
    classDef orange fill:#DE8F05,stroke:#000000,color:#FFFFFF,stroke-width:2px
    classDef teal fill:#029E73,stroke:#000000,color:#FFFFFF,stroke-width:2px

What Each Level Covers

Level	Coverage	Sections	Who It Is For
Beginner	0–40%	18	Anyone new to OpenClaw or autonomous agent frameworks
Intermediate	40–75%	13	Engineers ready to write custom skills and multi-agent workflows
Advanced	75–95%	11	Engineers deploying OpenClaw in production or extending the framework

Full Section Map

Beginner — 18 Sections

1. What is OpenClaw? — Agent framework vs. app, why messaging as UI, local-first meaning
2. Local-First Architecture — Why local, privacy implications, offline capability, latency advantages
3. The Seven Core Components — Overview of Channel, Gateway, Skills, Runtime, Memory, LLM, Local Execution
4. Installation and First Run — npm install or Homebrew, initial config wizard
5. LLM Provider Configuration — API key setup for Claude, GPT, DeepSeek; model selection; cost trade-offs
6. Your First Channel: Telegram — BotFather, bot token, connecting OpenClaw to Telegram
7. The Channel Abstraction — What channels are, why 24+ platforms all look the same to the agent
8. Gateway Fundamentals — Local control plane, how it routes messages to the agent runtime
9. Understanding AGENTS.md — Purpose, format, what system instructions to put in it
10. Understanding SOUL.md — Agent personality, name, tone, persona configuration
11. Understanding TOOLS.md — Tool capability declarations, what tools the agent can use
12. What is a Skill? — SKILL.md format intro, natural-language instructions, examples section, tools section
13. Installing Skills from ClawHub — Searching the registry, install command, verifying installation
14. Using Built-in Skills — What ships by default, how to invoke skills in conversation
15. The Agent Runtime Loop — LLM → tool call → tool result → LLM cycle, how it terminates
16. Memory Basics — Conversation context, what gets remembered within a session
17. Companion Apps — macOS menu bar app, iOS/Android apps, sync across devices
18. Security Foundations — What permissions OpenClaw requests, prompt injection risk, minimal-permission principle

Intermediate — 13 Sections

1. Writing Your First Skill — SKILL.md anatomy in depth: instructions block, examples block, tools block
2. Selective Skill Injection — How OpenClaw decides relevance, token budget, injection algorithm
3. Multi-Channel Routing — Different channels mapped to different agent personas
4. Agent Isolation — Isolated workspace per channel/account, why this matters for privacy
5. Memory System Deep Dive — Semantic search over conversation history, embedding storage
6. Knowledge Base Configuration — Adding PDF and markdown documents, indexed retrieval
7. Custom Tool Definitions in TOOLS.md — Declaring tools with JSON schema, permission scoping
8. Multi-Agent Orchestration — Running multiple OpenClaw instances, routing between agents
9. Voice Mode — Wake word setup, voice input, TTS output, macOS/iOS only constraints
10. Live Canvas and A2UI — Agent-driven visual workspaces, what the A2UI protocol enables
11. Debugging Agent Behavior — Trace mode, logging, understanding why the LLM chose a tool
12. Skill Composition — Combining multiple skills, resolving conflicts, ordering skills
13. ClawHub: Discovering and Sharing Skills — Browsing the registry, packaging, publishing a skill

Advanced — 11 Sections

1. Custom LLM Provider Integration — OpenAI-compatible APIs, local Ollama models, provider interface
2. Gateway Customization — Custom routes, webhooks, event handling, extending the control plane
3. Security Hardening — Prompt injection defenses, sandboxing execution, scoped permissions, audit logging
4. Building a Domain-Specific Agent — End-to-end: design, skills, channels, memory for a CRM agent
5. Multi-Agent Patterns — Specialist and orchestrator pattern, agent delegation, result aggregation
6. Memory Persistence Architecture — Long-term episodic memory, knowledge graph integration
7. ClawHub: Publishing Skills at Scale — Versioning, dependency management, testing skill packages
8. OpenClaw and Pi Architecture — How Pi (minimal agent harness) influenced OpenClaw's design
9. Production Deployment — Self-hosting considerations, reliability, monitoring, cost management
10. Performance Optimization — Context window management, skill pruning, token cost reduction
11. Contributing to OpenClaw — Codebase architecture (TypeScript core and Swift companion), PR workflow

How Each Section Is Structured

Every section in this track follows a consistent six-part format:

1. Concept title and introduction — what the concept is, why it matters, how it connects to what came before (2–3 sentences)
2. Diagram — a Mermaid flowchart or architecture diagram when the concept involves multiple components, data flows, or state transitions; omitted for trivial operations
3. Narrative explanation — how the concept works, when to use it, trade-offs, best practices, and pitfalls (3–10 paragraphs)
4. Annotated code examples — 1–5 examples with dense inline annotations using // => notation to document state, output, and reasoning at each step
5. Key Takeaway — the single most important insight from the section (1–2 sentences)
6. Why It Matters — how the concept connects to a real production concern such as cost, reliability, security, or scale (50–100 words)