OpenClaw: the open source AI agent that's revolutionizing automation

The AI world was rocked in late 2025 by the arrival of an open source project capable of turning any LLM into an autonomous agent running locally. That project, known today as OpenClaw, has gathered more than 145,000 GitHub stars and 20,000 forks in just a few weeks, an unprecedented phenomenon in the open source ecosystem. Here's the story of an extraordinary technical and legal journey, and what this tool actually changes for developers and AI enthusiasts.

From Clawdbot to OpenClaw: a turbulent story

The OpenClaw story begins in November 2025, when Austrian developer Peter Steinberger publishes a project on GitHub called Clawdbot. The idea is simple but powerful: build an autonomous, open source AI agent that runs entirely locally on the user's machine. Unlike conventional cloud solutions, Clawdbot sends no data to third-party servers without the user's explicit consent.

The project is an instant runaway success. Developers from all over the world flock to the repository, contribute code, open issues, and propose features. But that success also draws the attention of the industry's big players.

On January 27, 2026, Anthropic, the company behind the Claude model, files a trademark infringement complaint. The name "Clawdbot" is deemed too close to "Claude." Peter Steinberger reacts quickly and renames the project Moltbot. But that name only lasts three days: on January 30, 2026, the project adopts its final name, OpenClaw, a name that reflects both its open nature and its sharp edge.

What exactly is OpenClaw?

OpenClaw is an autonomous AI agent that runs locally on your machine. In practical terms, it acts as an intelligent intermediary between you and various large language models (LLMs). It can connect to Claude (Anthropic), DeepSeek, GPT (OpenAI), or any other compatible model, and carry out complex tasks autonomously.

What sets OpenClaw apart from conventional chatbots is the agent paradigm. A chatbot answers questions. An agent, on the other hand, acts. It can:

• Read and modify files on your machine
• Run system commands
• Browse the web to gather information
• Interact with external APIs
• Orchestrate sub-tasks in parallel
• Learn from its mistakes and adjust its strategy

You interact with OpenClaw through messaging platforms you already use every day: Signal, Telegram, Discord, or WhatsApp. You message your agent the way you would a coworker, and it carries out the requested task.

Local-first architecture: why it matters

OpenClaw's architecture rests on a fundamental principle: local-first. All of the orchestration logic, the agent's memory, the configuration files, and the context data stay on your machine. Only the requests to the LLMs travel across the network, and only to the provider you've chosen.

This approach offers several major advantages:

Data privacy

Your files, your source code, and your personal documents never leave your machine. That's a compelling argument for companies subject to strict regulations such as GDPR, or for developers working on sensitive projects. If you handle customer data, trade secrets, or proprietary code, local-first guarantees you full control.

Reduced latency

Local operations (reading files, running commands, manipulating data) execute without any network delay. Only the call to the LLM requires an internet connection, which dramatically reduces response times for hybrid tasks.

Total customization

Being open source, OpenClaw's code is fully auditable and modifiable. You can add custom tools, change the agent's behavior, and integrate your own workflows. In fact, the community has already produced hundreds of extensions.

Installation and first steps

Installing OpenClaw is relatively straightforward for a project of this scale. Here are the main steps on a Linux or macOS system:

# Clone the official repository
git clone https://github.com/psteinberger/openclaw.git
cd openclaw

# Install dependencies
npm install

# Copy and edit the configuration
cp .env.example .env
nano .env

# Start the agent
npm start

The .env file holds the API keys for the various LLM providers you want to use. You can configure several of them and let OpenClaw pick the best fit for the task.

Connecting to a messaging platform

To connect OpenClaw to Telegram, for example:

# In the .env file, add your Telegram token
TELEGRAM_BOT_TOKEN=your_token_here
TELEGRAM_ALLOWED_USERS=your_telegram_id

# Restart the agent
npm start -- --platform telegram

Once connected, you can interact with your agent directly from the Telegram app on your phone. The agent runs on your server or your local machine, and the messages travel through the Telegram API.

The agent paradigm: beyond the chatbot

To fully grasp the power of OpenClaw, you have to understand the fundamental difference between a chatbot and an autonomous agent.

A chatbot works in request-response mode: you ask a question, it answers. The conversation is linear and each exchange is relatively independent. An agent, by contrast, works in goal-execution mode: you define a goal, and the agent breaks that goal down into sub-tasks, executes them sequentially or in parallel, handles errors, and reports the final result back to you.

Let's take a concrete example. You ask OpenClaw: "Analyze my server logs from the past week, identify recurring errors, and suggest a fix for the three most frequent ones." The agent will then:

1. Locate the log files on your system
2. Parse them to extract the errors
3. Group the errors by type and frequency
4. Analyze the relevant source code (if accessible)
5. Propose fixes in the form of patches
6. Present you with a structured report

All of this happens in a single interaction. The agent manages the entire workflow, including error cases (file not found, unexpected format, etc.).

Multi-LLM: choosing the right model for each task

One of OpenClaw's strengths is its ability to use several LLMs simultaneously. You can configure routing rules so that certain tasks are handled by a specific model:

• Claude for complex reasoning tasks and code analysis
• DeepSeek for technical tasks in mathematics and programming
• GPT for content generation and rewriting
• Local models (via connecter OpenClaw à Ollama) for simple tasks that don't require an internet connection

This multi-model approach lets you optimize both the quality of the results and usage costs, since each model has its own pricing and its own strengths.

Security: the Achilles' heel

While OpenClaw has won over the community with its power and flexibility, the project isn't free of criticism, particularly around security. Several cybersecurity researchers have raised legitimate concerns:

• Expanded attack surface: an agent that can run system commands and modify files poses a significant risk if compromised
• Prompt injection: if the agent processes external data (web pages, emails), an attacker could inject malicious instructions into that data
• Lack of isolation: by default, OpenClaw runs with the same permissions as the user who launched it, with no sandboxing

These concerns have, in fact, given rise to NanoClaw, l'alternative sécurisée projects like NanoClaw, which puts security at the center of its architecture with container-based isolation from the ground up.

The ecosystem and the community

With its 145,000 GitHub stars, OpenClaw has become one of the most popular open source projects in recent history. The community is extremely active:

• More than 2,000 active contributors
• A plugin system for extending the agent's capabilities
• Workflow templates shared by the community
• Documentation translated into more than 15 languages
• Dedicated meetups and conferences in several countries

Peter Steinberger, the project's creator, continues to steer development while fostering community governance. Major architectural decisions go through RFCs (Requests for Comments) open to every contributor.

Real-world use cases

Beyond the theory, here are a few concrete use cases that illustrate the power of OpenClaw:

DevOps automation

OpenClaw can monitor your servers, analyze metrics, and make automatic decisions (scaling, restarting services, log rotation). Paired with a well-configured Docker environment, it becomes a formidably effective DevOps assistant.

Software development

The agent can write code, run tests, fix bugs, and even manage pull requests. Several development teams already use it as a permanent "pair programmer," accessible through a simple Telegram message.

Technology monitoring

Configured to browse the web at regular intervals, OpenClaw can gather information on specific topics, synthesize it, and send you a daily summary. It's a particularly popular use among researchers and tech journalists.

File and data management

Sorting, renaming, format conversion, extracting data from PDFs or spreadsheets: OpenClaw excels at data manipulation tasks that are repetitive but require a degree of contextual intelligence. To go further with data processing, our Python data processing tutorial will give you the foundations you need.

How to contribute to the project

If you'd like to contribute to OpenClaw, here's how to get started:

# Fork and clone the project
git clone https://github.com/your-username/openclaw.git
cd openclaw

# Create a branch for your contribution
git checkout -b feature/my-contribution

# Install development dependencies
npm install --dev

# Run the tests
npm test

# Submit a pull request
git push origin feature/my-contribution

The project follows a rigorous review process. Each pull request is reviewed by at least two maintainers before being merged. Automated tests must pass, and the code must follow the project's conventions.

What future for open source AI agents?

OpenClaw is part of a deeper trend: the democratization of AI agents. Where AI assistants were until now the preserve of big tech companies, projects like OpenClaw let any developer deploy their own agent, on their own infrastructure, with their own rules.

This trend raises fundamental questions. How do you regulate the use of autonomous agents with access to critical systems? Who is liable when an agent acting autonomously causes harm? How do you make sure these tools aren't hijacked for malicious purposes?

The answer will probably come from a combination of technical solutions (isolation, sandboxing, code auditing) and suitable regulatory frameworks. In the meantime, projects like OpenClaw show that the future of AI won't be dictated solely by the giants of Silicon Valley, but also by a global community of passionate, committed developers.