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: May 2026
Last reviewed: April 11, 2026
Update cadence: monthly scheduled review, with fast patches for major ecosystem changes

The Event That Changed Everything

In January 2026, an Austrian developer pushed his side project to GitHub.

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.

In six weeks the project passed 100,000 GitHub stars. Then 200,000. Then 346,000 — one of the fastest-growing open-source projects on record, according to coverage cited in SOURCES.md. Reports described lines outside tech offices in San Francisco and China. Jensen Huang took the GTC stage and called it “the operating system for personal AI — as big a deal as HTML, as big a deal as Linux.” Sam Altman called. Lex Fridman wanted an episode. Mark Zuckerberg watched with interest.

Peter Steinberger thanked everyone, submitted his job application, and joined OpenAI — not to build a company, but to change the world faster.

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.

Larry Ellison said it plainly on March 31, 2026, in remarks widely quoted alongside reports of large-scale Oracle job cuts: “We can build more software in less time with fewer people using AI.” Whatever one thinks about it, the directional claim — more software with fewer people — is already shaping boardroom conversations.

Harvard Business Review coined a new job title in February 2026: Agent Manager. Someone who leads, develops, and measures the results of AI agents — the same way a traditional manager leads human employees.

McKinsey identified nine organizational shifts driven by autonomous agents. Nine. Not a trend. Not a feature. Nine fundamental changes in how companies are structured, how decisions are made, how accountability is distributed.

The agentic layer — the control plane above the model — is one of the most valuable places in all of technology right now. OpenAI agreed to acquire Windsurf for $3 billion in May 2025, but the deal collapsed in July 2025 — Google ultimately hired Windsurf’s CEO and key engineers in a $2.4 billion talent and licensing deal. Press coverage has valued Cursor around $29–50 billion (Bloomberg, March 2026) and Lovable around $6.6 billion. All of them are selling fundamentally the same thing: 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 — FlowPilot/Flowwink as a production SaaS ERP with a native autonomous agent
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, Cursor, Cline, and Roo 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 SaaS/ERP stack — CMS, CRM, e-commerce, booking, and more — with FlowPilot designed as a native autonomous agent from day one
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

How FlowPilot Fits In

This is a handbook, not a product brochure.

Flowwink is a self-hosted SaaS ERP — comparable to Odoo in scope. Without FlowPilot it is a capable classic platform. With FlowPilot it becomes a Business Operating System (BOS): the agent operates the business autonomously while the human sets direction. FlowPilot is not a plugin or an add-on — the platform and the agent were designed together from the start.

The Market This Disrupts

Business process software is one of the largest markets in technology. SAP, Salesforce, Microsoft Dynamics, Oracle, and Workday collectively represent hundreds of billions in market capitalization — built on a single premise: humans need software to manage their business operations.

That premise is now in question.

Every one of those platforms was designed for a world where a human logs in, makes a decision, and clicks a button. The software executes. The human decides again. That loop is the product.

An autonomous agent doesn’t log in. It doesn’t wait to be asked. It operates the platform — qualifying leads, publishing content, processing orders, generating reports — while the human sets direction and approves the exceptions. The software is no longer the tool. The agent is the operator, and the software is the agent’s environment.

This is not a feature that SAP or Salesforce can bolt on. It requires rethinking the architecture from the ground up — where the agent is a first-class component, not an afterthought. That 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, April 2026

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.

The claw is the law.

How to read this: Start with chapters 1–4 for conceptual grounding. Jump to chapter 5 (Control Plane) if you’re a builder who wants the architecture fast. Read chapter 20 (Governance) if you’re a manager or Agent Manager. Read chapter 24 (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.