Foreword

Why this handbook exists, who it's for, and what a single developer building in his spare time taught the world about autonomous agents.

About This Edition

Edition: August 2026
Last reviewed: August 2026
Update cadence: monthly scheduled review, with fast patches for major ecosystem changes — the Revision History logs both editions, this one included, and the repository’s commit history is the audit trail beneath it
Agent-readable: the handbook exposes its own MCP surface — Streamable HTTP at https://www.clawable.org/api/mcp (tools: list_chapters, read_chapter, search_handbook; every chapter as a clawable:// resource), plus llms.txt and raw markdown at /raw/<track>/<slug>.md. A handbook about MCP that cannot be read over MCP would be unexamined by its own standard

The Event That Changed Everything

In November 2025, an Austrian developer released his side project to the world — and almost nobody noticed.

Peter Steinberger had built it for fun. He wanted an AI assistant that lived on his devices, talked on his channels, and actually remembered what he said. Not a chatbot. Not a tool you open and close. Something more like a colleague.

He called it OpenClaw.

The launch was quiet. His first posts about it barely registered — “it almost felt like a challenge: why can’t I explain how awesome this is?” So he stopped explaining and started showing: a public Discord where anyone could watch him improve his agent, automate his house, throw weird problems at it. Showing worked. In January 2026 the project took off — 346,000 GitHub stars within weeks, one of the fastest-growing open-source projects on record, according to coverage cited in SOURCES.md. By mid-2026, roughly half a million systems worldwide were running it.

Peter Steinberger thanked everyone, submitted his job application, and joined OpenAI — not to build a company, but to change the world faster. He works across product teams there, including Codex, building agent and multiagent systems: the man who designed the operator framework now builds the frontier’s agent layer from the inside.

What He Actually Built

OpenClaw is not technically revolutionary. It is beautiful in its simplicity.

Steinberger understood something every great systems thinker eventually understands: the hard part is not making AI smart. The hard part is giving AI continuity — an identity, a memory, a purpose that stays stable over time. An AI that wakes up knowing who it is. An AI that remembers what happened yesterday. An AI that has a goal and works toward it, even when no one is watching.

He solved it with three text files.

SOUL.md. AGENTS.md. HEARTBEAT.md.

It sounds absurdly simple. It is. That’s why it works.

In SOUL.md you write who the agent is. What it values. How it speaks. What it never does. In AGENTS.md you write how it should work — the rules, the boundaries, what happens at the edge cases. In HEARTBEAT.md you write what it should do when you’re not there — a simple checklist the agent works through every 30 minutes, alone, while you sleep.

Three files. A continuous, learning, self-directing agent.

That is Steinberger’s brilliant achievement: not the model, not the infrastructure — the framework. The design of how an autonomous system should be organized to work reliably over time. That insight has spread to Claude Code, to Cursor, to Cline, to Flowwink and FlowPilot. Many of the leading teams building autonomous agents today are building, consciously or not, on Steinberger’s design philosophy.

Why You Should Read This

We are living in a moment without historical parallel.

The agentic layer — the control plane above the model — is one of the most valuable places in all of technology right now. In June 2026 it got its definitive price tag: SpaceX acquired Cursor’s parent Anysphere for $60 billion — the largest acquisition of a venture-backed startup ever, roughly fifteen times revenue. Sixty billion dollars, for a company that trains no frontier models of its own. What it sells is a well-constructed agent layer on top of models someone else builds.

The model is not the product. The lantern around the model is.

The person who understands how the lantern works — how to build a system that is more than a thin wrapper, how to create an agentic control plane with real data, real integrations, and a memory that can’t be copied — that person is in an exceptionally strong position.

That person can be you.

What This Handbook Does

It explains, from first principles, how the agentic architecture works.

Not in theory. In code, in production systems, in verified claims against OpenClaw’s source code.

The narrative arc is deliberate:

What agentic is — agency, persistence, adaptation, and control-plane design
How to build it for business — FlowWink as a Business Operating System operable by any agent, with FlowPilot as its built-in operator
How to prove it stays agentic — testing, governance, and drift controls
How to improve it continuously — external autonomous agents auditing and upgrading the system in a closed loop

We cover:

OpenClaw’s actual architecture — system prompt, workspace files, heartbeat, skills, sessions — and what the source code actually confirms
The agentic control plane — how Claude Code, Codex, Antigravity, Cursor, and Cline work under the hood, why thin wrappers fail, and what a defensible moat requires
The API layer — the three diverging formats (Chat Completions, Responses, Messages) and how adapters like LiteLLM preserve portability
Flowwink as a production self-hosted Business Operating System — 68 modules across CMS, CRM, commerce, finance, HR, and operations, every capability exposed as an agent skill — with FlowPilot as the built-in operator and the freedom to bring your own
Agent-Driven Development (ADD): how agents test and evaluate other agents through A2A dispatch, MCP inspection, and structured findings
The governance shift — the Agent Manager role, McKinsey’s accountability model, and who is responsible when an agent makes a bad decision
The two production failure modes teams repeatedly hit — stagnation and drift — and practical ways to manage both
Where this is heading next, based on recently verified sources and ecosystem signals

Short on time? These eleven chapters are the machine. Start with the harness (5b) — it is the map of all the others: the laws (9), the heartbeat (10), MCP under the hood (12), intent scoring (17), memory (18), the token economy (19), stagnation and drift (21), production patterns (25), resilience (31), and tool-hallucination recovery (32). Everything else is context, evidence, and ecosystem — valuable, but those eleven are what you cannot get from a blog post. Read them in any order; each states the problem it solves.

How FlowPilot Fits In

This is a handbook, not a product brochure.

Flowwink is a self-hosted Business Operating System (BOS) — comparable to Odoo in scope, but built on a different premise: every capability of its 68 modules is exposed as an agent skill over MCP, so the platform is operable by any agent. It ships with one — FlowPilot, the flagship module: an opt-in operator layer that adds soul, objectives, heartbeat, memory, and trust gating on top of the always-on platform. Switch FlowPilot off and FlowWink is still a fully capable classic platform, still agent-operable from outside. Switch it on and there is a colleague behind the interface that also acts when nobody is typing. The platform and the agent were designed together — but the architecture never locks you to the built-in operator. Bring your own.

The Market This Disrupts

Business process software — SAP, Salesforce, Dynamics, Oracle, Workday — represents hundreds of billions in market capitalization, all built on one premise: a human logs in, decides, and clicks. That loop is the product.

An autonomous agent breaks the loop. It doesn’t log in and it doesn’t wait to be asked — it operates the platform while the human sets direction and approves the exceptions. The software stops being the tool and becomes the agent’s environment.

That is not a feature the incumbents can bolt on. It requires an architecture where the agent is a first-class component from the ground up — which is what Flowwink was designed to be.

FlowPilot/Flowwink appears throughout these chapters as a concrete worked example of what it looks like to design and operate this kind of system in production. It is one implementation of the patterns described here, not the only one.

If you are building your own agentic business system — or wiring a stock OpenClaw instance into an existing product — you can use Flowwink as a reference for:

How to design a business platform where the agent is a first-class architectural component
How to structure persistent memory in PostgreSQL rather than files
How to wire a stock OpenClaw instance into your own system as a peer via /v1/responses and A2A — no fork required

The goal is for you to build your own version, not to adopt ours.

One More Thing

One of the most important lines in Steinberger’s blog post from February 2026 — written three days after the entire tech world wanted to acquire him — was not that he joined OpenAI.

It was this:

“Yes, I could totally see how OpenClaw could become a huge company. And no, it’s not really exciting for me. I’m a builder at heart.”

That feeling — that the real value is in building, not in getting rich from it — is what drives all technology development that actually matters.

Steinberger built OpenClaw in his spare time, published it, and fundamentally changed how the world understands what an AI agent can be. An Austrian indie developer, a text file called SOUL.md, and a lobster that took over the world.

How large is the opportunity for those who actually understand how it works?

That is what we are trying to give you in this handbook.

— The Clawable Project

With genuine and deep thanks to Peter Steinberger — for choosing to build in the open, share generously, and show that one person with the right idea can still change the direction of an entire industry.

And to the teams whose platforms carry every proof in this book: Anton Osika and Lovable, which made FlowWink buildable in weeks — and Supabase, which everything runs on: the Postgres the operators read, the RLS that scopes them, the edge functions their skills execute through, the pgvector they remember with. When this handbook talks about auditable stacks, that is the stack.

The claw is the law.

How to read this: Start with chapters 1–4 for conceptual grounding. Jump to chapters 5 and 5b (the Control Plane and the Harness) if you’re a builder who wants the architecture fast — 5b maps the whole machine in eleven components. Read chapter 23 (Governance) if you’re a manager or Agent Manager. Read chapter 27 (Agent-Driven Development) if you want to understand how agents improve agents. Read all of it if you want the full picture — it’s written as a coherent argument, not just a reference.