The Origin Story - How a Vacation Side Project Became the Fastest-Growing AI Agent in History

A Developer on Vacation with an Idea

Most breakout open-source projects do not start with a grand plan. They start with a frustrated developer, a laptop, and some free time. OpenClaw is no different. Peter Steinberger, already well known in the developer community as the founder of PSPDFKit, was on vacation when the idea first took shape.

Peter had been experimenting with large language models and found himself underwhelmed by the state of AI tooling at the time. Chatbots were everywhere, but they were passive. You could ask them questions and get answers, but you could not hand them a task and walk away. The gap between conversational AI and agentic AI felt enormous. What if you could build something that actually acted on your behalf, talked to your services, responded to messages, and ran on infrastructure you controlled?

That question became the seed of what would eventually grow into one of the most popular open-source projects in the AI ecosystem.

Clawdbot: The First Commit

The earliest version of the project was called Clawdbot. The name was a playful mashup -- a nod to both the "claw" of a machine reaching out to do work and the digital "bot" part that had become ubiquitous in developer culture. Peter published the first commits to a public GitHub repository with minimal documentation and a working prototype that could respond to messages on Telegram.

Even in those early days, the architecture hinted at something more ambitious than a simple chatbot. Rather than tightly coupling the bot to a single messaging platform, Peter designed a channel abstraction layer. The bot did not care whether a message came from WhatsApp, Discord, or a web interface. It processed intents, executed tasks, and replied through whatever channel had initiated the conversation.

This architectural decision turned out to be one of the most important in the project's history. It meant that as new messaging platforms gained popularity, adding support was a matter of writing a thin adapter rather than rearchitecting the core.

The Name Changes: Moltbot and the Road to OpenClaw

Trademark issues are the unglamorous reality of open-source naming. Clawdbot ran into exactly that problem. The name was too close to existing trademarks, and Peter decided it was better to rename early rather than deal with legal headaches later.

The project was briefly renamed to Moltbot. "Molt" referred to the biological process of molting -- shedding an old shell to grow a new, larger one. It was a fitting metaphor for AI agents that evolve and adapt. But Moltbot had its own issues. The name did not resonate with the broader community, and there were concerns about discoverability and branding.

The final name, OpenClaw, landed on the right balance. It preserved the "claw" identity from the original project, added "open" to signal the commitment to open source, and was distinctive enough to avoid trademark conflicts. The lobster mascot, which would later become iconic, emerged naturally from the molting metaphor that had been part of the project's DNA since the Moltbot era.

Architecture Decisions That Mattered

Several technical choices made in those early months set OpenClaw apart from other AI agent projects that were appearing around the same time.

The Gateway

OpenClaw introduced a central coordinator called the Gateway. Rather than having agents directly connect to channels and services, all communication flows through the Gateway. This creates a single point of configuration and monitoring. When something goes wrong, you know where to look. When you want to add a new capability, you plug it into the Gateway rather than modifying every agent individually.

Multi-Agent from Day One

Most competing projects treated a single AI agent as the unit of deployment. OpenClaw was designed from the start to support multiple agents running on the same instance. Each agent could have its own personality (defined in a soul.md file), its own set of skills, and its own channel bindings. This multi-agent architecture meant a single OpenClaw deployment could handle customer support on one channel while running internal automation on another.

The Skills Ecosystem

Rather than building every capability into the core, Peter created a plugin system called skills. Skills are self-contained modules that give agents new abilities -- from sending emails to browsing the web to interacting with APIs. This decision kept the core lightweight while making the platform extensible. It also laid the groundwork for ClawHub, the community marketplace for sharing skills.

The Viral Moment

OpenClaw's growth was not a slow burn. It was more like a series of escalating waves. The first significant wave came when a popular developer on Twitter posted a thread showing how they had set up an OpenClaw agent to manage their small business's customer inquiries across WhatsApp and a website widget. The thread went viral because it showed something people had been wanting but did not know existed: a self-hosted AI agent that actually worked in production.

GitHub stars began climbing rapidly. The repository went from a few hundred stars to tens of thousands in a matter of weeks. Contributors started appearing from around the world, submitting pull requests for new channel adapters, skills, and documentation improvements.

The second wave came when the developer community realized that OpenClaw was not just a chatbot framework. People began using it for workflow automation, internal tooling, and even creative projects. Someone built a skill that let their OpenClaw agent manage a Discord community. Another developer created an agent that monitored server infrastructure and alerted them through Telegram. The flexibility of the platform meant that use cases the original developer never imagined were emerging organically from the community.

From Solo Project to Community Effort

As the project grew past 50,000 GitHub stars, it became clear that one person could not maintain it alone. Peter had experience scaling engineering teams from his PSPDFKit days, and he applied that knowledge to building a contributor community.

The project adopted a clear contribution guide, established a code review process, and created specialized teams for different areas of the codebase -- core, channels, skills, and documentation. Regular community calls gave contributors a voice in the project's direction. The Discord server grew into a thriving space where newcomers could get help and experienced users could share advanced configurations.

This was also the period when the openclaw.json configuration file stabilized into its current form. Early versions of the project required editing multiple files to configure an agent. The community pushed for a single, well-documented configuration file, and openclaw.json became the standard way to define everything from which AI model to use to which channels to enable.

Peter's Move to OpenAI and What It Meant

In early 2026, Peter Steinberger announced that he was joining OpenAI to work on agentic systems. The news sent a ripple through the community. Would OpenClaw become an abandoned project? Would it be absorbed into OpenAI's commercial offerings?

Peter addressed these concerns directly. Before joining OpenAI, he worked with the community to establish the OpenClaw Foundation, an independent body that would govern the project going forward. The Foundation ensured that no single company or individual could control OpenClaw's direction. The MIT license remained in place. The contributor community retained decision-making power through the Foundation's governance structure.

Peter's move to OpenAI was, in many ways, a validation of the ideas behind OpenClaw. The largest AI company in the world was investing in agentic systems, and the person they recruited to help build them was the one who had demonstrated what was possible with an open-source approach.

myHermy and the Sustainability Question

Open-source sustainability is one of the hardest problems in software. Projects that depend entirely on volunteer labor often stagnate once the initial excitement fades. OpenClaw addressed this partly through myHermy, a managed hosting platform built on Hetzner Cloud VPS infrastructure.

myHermy provides a commercial service -- deploying and managing OpenClaw instances -- while the core framework remains fully open source and free. This model allows developers who want full control to self-host on their own infrastructure, while teams and businesses that prefer a managed solution can use myHermy. The revenue from myHermy helps fund ongoing development and community infrastructure.

This approach is not unique to OpenClaw. Projects like WordPress (with WordPress.com), GitLab, and Discourse have successfully used similar models. But the execution matters, and myHermy's tight integration with OpenClaw -- from one-click deployments to built-in diagnostics and terminal access -- demonstrates that a commercial layer can enhance rather than undermine an open-source project.

140,000 Stars and Counting

Reaching 140,000 GitHub stars is a milestone that puts OpenClaw among the most popular open-source projects on the platform. But star counts alone do not tell the full story. What matters more is the active contributor base, the growing skills ecosystem on ClawHub, and the diversity of use cases the community has built.

OpenClaw agents are running customer support for small businesses. They are managing smart home devices. They are serving as personal assistants that respond through WhatsApp. They are automating DevOps workflows. They are even being used in educational settings to create interactive tutoring agents.

The project that started as a vacation experiment has become a platform. And the growth shows no signs of slowing down.

Lessons from the Journey

OpenClaw's trajectory offers several takeaways for developers thinking about building open-source projects.

Solve a real problem. OpenClaw did not succeed because of clever marketing. It succeeded because it addressed a genuine gap: people wanted AI agents that could act autonomously, run on their own infrastructure, and connect to the messaging platforms they already used.

Architecture matters early. The decision to build a channel abstraction layer and multi-agent support from the beginning meant that OpenClaw could scale in ways that more tightly coupled projects could not. Rearchitecting after the fact is orders of magnitude harder.

Community is not optional. No single developer, no matter how talented, can sustain a project at this scale. Building contributor infrastructure -- documentation, code review processes, communication channels, governance -- is as important as writing code.

Plan for succession. Peter's foresight in establishing the OpenClaw Foundation before joining OpenAI ensured that the project's future was not tied to any one person. Open-source projects that depend on a single maintainer are inherently fragile.

The story of OpenClaw is still being written. But the chapters so far -- from a vacation idea to a global community -- demonstrate what happens when a good idea meets solid engineering and an engaged community.