# Build Your Own OpenClaw

czl9707's `build-your-own-openclaw` is a Python tutorial that constructs a Claude Code-style coding agent from scratch in 18 numbered steps, grouped into four phases. The name is a pun — OpenClaw is what you get when you're allowed to say "Claude Code" sideways. MIT-licensed, 917 stars as of April 2026, no published releases (the tutorial *is* the artifact). A reference implementation called `pickle-bot` ships alongside and demonstrates the final shape.

The progression is pedagogically deliberate: each step adds one concept, and the order matches the historical order in which real coding agents grew complex. If you want to understand why Claude Code, [[pi-coding-agent]], Cursor, and their peers converged on similar architectures, this is the cheapest way to walk the path end to end.

## Phase 1 — Single agent capability (steps 0-6)

The minimum viable coding agent. Starts with a bare chat loop, then layers in:

- **Tool calls** — the LLM can request actions (read file, run command) and get results back
- **Skill extension via documentation** — loading markdown skill files at startup so the agent can learn new capabilities without code changes (this is the same pattern Claude Code uses for skills)
- **Conversation persistence** — sessions survive restarts
- **User commands** — slash commands, interrupts, manual steering
- **History compaction** — summarizing old turns when the context window fills, a load-bearing technique for any long session
- **Web access** — adding a fetch tool so the agent can read URLs

By the end of Phase 1 you have something that resembles Claude Code in its simplest form: a REPL with tools and a growing toolbox of skills.

## Phase 2 — Event architecture (steps 7-10)

Rewrites the agent as an event-driven service. This is the architectural jump from "a Python script you run in a terminal" to "a process that stays up and accepts work from multiple sources." Steps cover:

- An internal event system
- Config hot-reload (edit the config file, the agent picks it up without a restart)
- Multi-channel support (one agent instance reachable from CLI, Slack, Telegram, etc., simultaneously)
- WebSocket integration for real-time frontends

## Phase 3 — Autonomous and collaborative (steps 11-15)

The agent gains the ability to initiate work on its own and to hand off to other agents:

- Intelligent routing — deciding which sub-agent should handle a given request
- Cron-scheduled tasks — the agent runs jobs on a timer, not just on user prompts
- Multi-layer prompting — layering system prompts, skill prompts, task prompts
- Bidirectional messaging — the agent can message users, not just respond
- Agent-to-agent dispatch — spawning and coordinating other agents

This phase is where multi-agent coordination starts looking like a real distributed systems problem, which is exactly the territory [[log-distributed-llms]] warns about. Building it by hand is a good way to feel the FLP/Byzantine corners in practice.

## Phase 4 — Production readiness (steps 16-17)

Concurrency management and persistent memory. The tutorial doesn't go deep on infrastructure, but it covers the basic shape: what changes when multiple users hit the same agent at once, and how memory spans sessions without exploding the context window. [[hippo-memory]] and [[mempalace]] are both deeper takes on the persistent memory problem.

## Tech notes

The project uses LiteLLM for provider abstraction, so the same agent code runs against Anthropic, OpenAI, local models, or anything else LiteLLM supports. This keeps the tutorial model-agnostic — the point is the architecture, not which LLM is behind it.

## Where this fits

For someone who already uses Claude Code, the value of this tutorial isn't learning *how to use* an agent — it's seeing the skeleton underneath one. Each phase maps directly to features you already interact with daily:

- Phase 1 → the basic loop, tools, skills, session files
- Phase 2 → hooks, the MCP surface, multi-surface reach
- Phase 3 → subagents, scheduled tasks, the Task tool
- Phase 4 → background processes, persistent memory across sessions

Closest cousins in the wiki: [[pi-coding-agent]] (a minimal terminal coding agent — smaller scope, similar philosophy), [[agent-reading-test]] (benchmark for whether agents can read docs), [[chiasmus]] (MCP server adding formal tools), [[hippo-memory]] / [[mempalace]] (the memory side of Phase 4), [[botctl]] (a production-grade process manager for the kind of agent this tutorial teaches you to build).