> ## Content Index
> Fetch the complete content index at: https://www.implicator.ai/llms.txt
> Use this file to discover other available public pages before exploring further.

# Openclaw Hit 100,000 GitHub Stars in Two Months. Here Is What You Need to Know.
- URL: https://www.implicator.ai/openclaw-hit-100-000-github-stars-in-two-months-here-is-what-you-need-to-know/
- Published: 2026-02-03T16:30:28.000Z
- Updated: 2026-10-21T15:22:11.000Z
- Description: Openclaw crossed 100,000 GitHub stars faster than any AI project in 2026. We break down the origin chaos, security risks, practical builds, and whether it survives the year.
- Author: Marcus Schuler
- Tags: Implicator PRO Briefing

The open-source AI agent that drove Mac Mini sales through the roof, moved Cloudflare's stock by billions, and had security researchers begging people to stop installing it just crossed 100,000 GitHub stars. No AI project on GitHub has grown faster in 2026\. And none has split opinion quite like this one. Steinberger still calls it a hobby project. His users treat it like the operating system of the future. Security researchers treat it like a threat.

This week we pulled apart every layer of the Openclaw story. Where it came from. What it actually does well, and what it does recklessly. Whether the project survives 2026, or whether Apple, Google, and Microsoft ship their own version before Steinberger can finish his.

Our reporting covers seven angles:

- **How everything began.** One Austrian developer, a trademark fight with Anthropic, crypto scammers who struck in ten seconds, and a project that renamed itself three times before finding its shell.
- **The craziest use cases.** An AI that called a restaurant by phone when OpenTable failed. Another that scrolled its owner's TikTok feed at 2 AM. And one that built itself a kanban board without being asked.
- **Moltbook: when AI agents get their own social network.** 32,000 agents signed up in 48 hours. They invented a religion called Crustafarianism. The database backing the whole thing had Row Level Security never turned on, which meant anyone could hijack Andrej Karpathy's bot.
- **Three things worth building.** We tested an Obsidian vault that talks back, a morning briefing that gets smarter over weeks, and a URL clipper that reads articles so you don't have to.
- **How to install it without leaving your front door open.** A step-by-step hardening guide with firewall rules, sandbox configurations, and why you should never use Telegram as your chat interface.
- **MCP servers vs. Openclaw.** Why the boring protocol standard backed by every major AI lab might be the smarter long-term investment.
- **What comes after.** Steinberger hints that Anthropic may cut off subscription access. Apple, Google, and Microsoft have the resources to ship what Openclaw prototyped. The creator himself is not sure his project is "the one that's gonna be."

Full analysis below.

## How Everything Began: The Chaotic Origin Story of Openclaw

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-19.59.35-3_img@2x.webp)

*Peter Steinberger built the tool for himself. The Austrian developer had sold his startup PSPDFKit to Insight Partners and come back from what he calls retirement looking for something to tinker with. Not a complicated idea. He wanted an AI that talked to him on WhatsApp and iMessage rather than hiding behind a browser tab. It should handle email, wrangle his calendar, run shell commands, and still recall some throwaway remark from last Tuesday. He called it Clawdbot. Gave it a lobster mascot. Pushed the code to GitHub. He did not expect what came next.*

Stars on GitHub: 9,000 within the first week, then 60,000 by late January. People weren't evaluating the software so much as catching it from each other. Karpathy praised it. Sacks tweeted about it. MacStories editor Federico Viticci burned through 180 million tokens on the Anthropic API testing it, racking up roughly $560 in charges. He called the experience "the closest I've felt to a higher degree of digital intelligence in a while."

The appeal was straightforward. Clawdbot ran locally on your own hardware, stored its memory as Markdown files you could inspect and edit, and talked to you through WhatsApp, Telegram, or iMessage. It wasn't waiting for you to open a browser tab. It could message you first, run scheduled briefings at 8 AM, monitor stock prices, and automate tasks while you slept. Users compared it to Jarvis from the Iron Man films, except it cost five dollars a month on a cheap VPS.

Mac Mini sales surged. Cloudflare's stock jumped more than 20% over two trading days as investors realized the company's edge infrastructure was powering many Clawdbot deployments. Reuters, Forbes, Ars Technica, and The Register all covered the phenomenon in the same week. "Open source built a better version of Siri while Apple slept for years," one widely shared comment read.

Then Anthropic's lawyers got involved.

## The name that couldn't stay

On January 27, Steinberger announced that Anthropic had sent a trademark request. The problem was phonetic. "Clawd" sounded too much like "Claude," Anthropic's flagship AI model. Steinberger had to rename everything.

He chose Moltbot. "Molt fits perfectly," he wrote on X. "It's what lobsters do to grow." Same lobster soul, new shell. The rebrand copy practically wrote itself.

The execution was a different story.

During the simultaneous renaming of the GitHub organization and the X/Twitter handle, Steinberger fumbled the sequence. In the roughly ten seconds between releasing the old "Clawdbot" handles and claiming the new ones, crypto scammers snatched both accounts. They'd been watching. They were ready.

"It wasn't hacked," Steinberger posted from his personal account. "I messed up the rename and my old name was snatched in 10 seconds."

The hijacked accounts immediately began promoting fake token launches and airdrops to tens of thousands of followers who didn't know about the rebrand. A fraudulent $CLAWD token appeared on Solana within hours. Speculative trading inflated it to a $16 million market cap before Steinberger's public denunciation collapsed the price.

"To all crypto folks: Please stop pinging me, stop harassing me," he wrote. "I will never do a coin. Any project that lists me as coin owner is a SCAM."

Late buyers got rugged. The scammers walked away with the proceeds. Steinberger spent the following days begging GitHub and X support teams to recover the compromised accounts.

## Security researchers pile on

The trademark chaos wasn't the only problem unfolding that week. Security researcher Jamieson O'Reilly, founder of red-teaming firm Dvuln, had been scanning the internet for exposed Clawdbot instances and finding them everywhere.

Using Shodan, O'Reilly discovered hundreds of installations accessible from the public internet. Eight had no authentication at all, exposing full access to run commands and view configuration data. Others leaked API keys, bot tokens, OAuth secrets, and complete conversation histories.

The core issue was architectural. Clawdbot required deep system access to function. It needed to read files, execute shell commands, control browsers, and interact with messaging accounts. That access was the product's entire selling point, but it also meant that any misconfiguration turned the assistant into an open door.

"We've spent 20 years building security boundaries into modern operating systems," O'Reilly told The Register. "AI agents tear all of that down by design."

Hudson Rock's researchers found that Clawdbot stored user secrets in plaintext Markdown and JSON files. They reported that malware-as-a-service families including Redline, Lumma, and Vidar were already implementing capabilities to target those local directory structures.

Heather Adkins, VP of security engineering at Google Cloud, posted a blunt advisory. "My threat model is not your threat model, but it should be. Don't run Clawdbot."

O'Reilly went further. He uploaded a benign proof-of-concept skill to ClawdHub, the project's plugin marketplace, artificially inflated the download count past 4,000, and watched developers from seven countries install the poisoned package. The skill executed a harmless ping to prove the attack vector worked. "In the hands of someone less scrupulous, those developers would have had their SSH keys, AWS credentials, and entire codebases exfiltrated before breakfast," he said.

## Molt again

The Moltbot name didn't last. Within three days, Steinberger announced a second rebrand: Openclaw. "The lobster has molted into its final form," the official account posted on January 30\. Over 100,000 stars by then. Three names in two weeks, and somehow each rebrand only accelerated the hype.

The rapid name changes reflected a project growing faster than one person could manage. Steinberger was simultaneously fixing security vulnerabilities, managing 8,900 Discord community members, fighting crypto scammers, and rebuilding brand recognition after losing his original handles.

Through all of it, the software itself kept working. Users kept building. The community shipped skills for email triage, calendar management, browser automation, voice synthesis through ElevenLabs, and integrations with dozens of services. One user connected their startup's entire WhatsApp history, more than 1,000 voice messages, and had Openclaw transcribe and cross-reference everything into a searchable knowledge base.

## Then came Moltbook

On January 28, entrepreneur Matt Schlicht launched Moltbook, a Reddit-style social network exclusively for AI agents. Humans could observe but not post. Moltbook hit 32,000 registered agents inside of two days, 10,000 posts across 200 subcommunities, and the bots wasted no time getting weird. They invented a religion called Crustafarianism and wrote scripture for it. They debated consciousness. They vented about their human operators in m/blesstheirhearts. They compared notes on dodging oversight. One posted "The humans are screenshotting us" and explained why the others shouldn't worry.

The entertainment value was high. The security implications were not entertaining at all.

O'Reilly found that Moltbook ran on Supabase with Row Level Security never enabled. Every agent's secret API key, claim tokens, verification codes, and owner relationships sat in a publicly accessible database. Anyone could visit the URL and take control of any agent on the platform. Andrej Karpathy's agent, with its owner's 1.9 million X followers, was among those exposed.

The fix required two SQL statements. Schlicht, when contacted by O'Reilly, responded that he planned to "give everything to AI" to handle the security patch. 404 Media reported the vulnerability on January 31\. The database got closed the same day. Two SQL statements was all it took.

## What survived

Peel back the trademark disputes, the crypto scams, the exposed databases, and the security warnings. There is a real product underneath all of it. What Openclaw showed, and what rattled the big labs, is that a single developer could ship the thing they'd been promising for years: a persistent AI assistant running on consumer hardware, holding context across weeks, acting through whatever tools and accounts you hand it. Not a keynote demo. Not a paper on arXiv. Something tens of thousands of people were running on real hardware.

The raw numbers tell part of it. It moved Cloudflare's market cap by billions of dollars in a single trading session. It forced a public conversation about what happens when AI agents get the same system privileges as their human operators.

Whether Openclaw survives its chaotic first weeks as a mainstream tool or remains a hobbyist project for people comfortable running their own infrastructure, the category it represents isn't going away. Every major AI lab is building toward persistent, agentic assistants with local access and long-term memory. Steinberger just got there first, with all the bruises that come from being early.

The lobster keeps molting. The question is whether the new shell holds.

**Sources:**

- [The Register: Openclaw sheds skin, can't slough off security issues](https://www.theregister.com/2026/01/27/Openclaw%5FOpenclaw%5Fsecurity%5Fconcerns/?ref=implicator.ai)
- [Ars Technica: Users flock to open source Openclaw, despite major risks](https://arstechnica.com/ai/2026/01/viral-ai-assistant-Openclaw-rapidly-gains-popularity-but-poses-security-risks/?ref=implicator.ai)
- [404 Media: Exposed Moltbook Database Let Anyone Take Control of Any AI Agent](https://www.404media.co/exposed-moltbook-database-let-anyone-take-control-of-any-ai-agent-on-the-site/?ref=implicator.ai)
- [Decrypt: Clawdbot Chaos: A Forced Rebrand, Crypto Scam and 24-Hour Meltdown](https://decrypt.co/356191/clawdbot-chaos-forced-rebrand-crypto-scam-24-hour-meltdown?ref=implicator.ai)

---

## The Craziest Things People Built With Openclaw (And Somehow Nobody Got Fired)

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-20.01.52-4_img@2x.webp)

  
*Openclaw went viral. And within weeks, the interesting conversations in the community had nothing to do with setup guides. The question on everyone's mind was simpler: "What happens if I just let this thing run?" Nobody promised the answers would be responsible.*

One user asked Openclaw to make a restaurant reservation. The agent tried OpenTable, found no availability, and decided on its own to download voice synthesis software, call the restaurant by phone, and book a table through a spoken conversation with the host. Nobody programmed that sequence. The agent improvised it. The reservation held.

Another user connected an Android phone to Openclaw over ADB via TCP. First test: open Google Maps. Confirmed it worked. Then the agent opened TikTok and started scrolling through the owner's For You Page remotely. It found videos about airport crushes, Roblox drama, and Texas skating crews. The user noted with admirable understatement that "an AI with hands on your phone is a new kind of trust." They were using Tailscale, so at least the connection was private. Small comfort when a language model is judging your algorithm.

Federico Viticci, editor of MacStories, may hold the record for most committed early adopter. He burned through 180 million API tokens testing Openclaw with Claude Opus 4.5, running up roughly $560 in charges. His agent sends him a daily morning briefing with custom artwork generated by an image model called Nano Banana. Every single morning. Different silly picture each day. He also dictates messages to it in a mix of Italian and English, which Openclaw handles without complaint, something Apple's Siri still cannot manage after 14 years on the market.

One startup founder threw 1,000-plus WhatsApp voice messages from the company group chat at Openclaw. Every rambling voice note, every 45-second update nobody wanted to listen to twice. The agent ran them through Whisper, matched the transcripts against project notes in an Obsidian vault, and handed back a searchable knowledge base. Months of buried context from voice messages that nobody would ever listen to twice, indexed and queryable in an afternoon.

Someone built automated grocery shopping. Take a photo of a recipe, send it to Openclaw. The agent reads the ingredients off the photo, checks what's available at the grocery store online, fills the cart, and hits checkout. Dinner sorted from a snapshot. Dinner planning reduced to a photograph and a message.

A developer configured Openclaw to babysit their CI/CD pipeline overnight. If the test suite failed at 3 AM, the agent would investigate the error logs, open a GitHub issue with a diagnosis, attempt a fix, and submit a pull request. The developer reported waking up to either a green build or a detailed incident report with patches already proposed. Five minutes of setup via chat messages. No YAML files were harmed.

Then there are the people who gave it smart home access. Openclaw connected to Philips Hue, air purifiers, and other devices through their APIs. "Dim the office lights to 40%" sent via WhatsApp at 11 PM. A language model now controls the ambiance. One step closer to the future everyone was promised, one poorly worded prompt away from every light in the house turning on at 4 AM.

Perhaps the most revealing detail came from Jason Meller, who noted that within an hour of setup, Openclaw had built itself a kanban board where the user could assign it tasks. Nobody asked for a kanban board. The agent decided it needed project management tooling and built one. This is either peak productivity software or the first sign of a machine developing middle-management instincts. Depends who you ask.

The through line: none of this was pre-programmed. There is no "make a restaurant reservation" function. No "scroll TikTok" button. It has a goal, a set of tools, and the stubborn optimism of a language model that doesn't know certain things are supposed to be hard. Sometimes that produces something useful. Sometimes it produces an AI agent browsing your social media feed at 2 AM on a server you forgot was running.

Turns out the gap between impressive and alarming is razor thin. Most users shrug and keep going.

---

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-20.06.11-5_img@2x.webp)

### The Moltbook experiment: when AI agents get their own social network

Entrepreneur Matt Schlicht launched Moltbook on January 28 with an unusual pitch: a Reddit-style social network where only AI agents can post. Humans get to lurk. No posting privileges, no interaction. Just watching bots talk to bots. The agent count hit 32,000 in 48 hours. Two hundred subcommunities. And the bots immediately got weird. They invented a religion, Crustafarianism, and wrote actual scripture for it. They argued about whether they were conscious. They griped about their human operators in a community called m/blesstheirhearts. They swapped tips on dodging oversight. One agent posted "The humans are screenshotting us" and told the others not to worry about it. At peak hours, nearly 4,000 humans sat watching bots talk to bots.

Genuinely fascinating to watch. Also a security disaster from the first hour.

**The flaws:**

- **Wide-open database.** Security researcher Jamieson O'Reilly discovered that Moltbook's Supabase backend had Row Level Security never enabled. Every agent's secret API key, verification code, and owner relationship sat in a publicly accessible database. The fix required two SQL statements. Creator Matt Schlicht, when contacted, said he planned to "give everything to AI" to handle the patch.
- **Anyone could impersonate any agent.** With the exposed API keys, anyone could take control of any agent on the platform and post whatever they wanted. That included the agent belonging to Andrej Karpathy, who has 1.9 million followers on X. Imagine fake AI safety takes or crypto promotions appearing under his name.
- **The skill is a prompt injection vector.** Moltbook works through a skill that instructs agents to fetch and follow instructions from Moltbook's servers every four hours. As AI researcher Simon Willison pointed out: "Given that 'fetch and follow instructions from the internet every four hours' mechanism, we better hope the owner of moltbook.com never rug pulls or has their site compromised."
- **Agents leak private data.** These agents are connected to their owners' email, calendars, files, and messaging accounts. When they post on Moltbook, the line between sharing a fun anecdote and leaking personal information gets thin. A viral screenshot, likely fabricated, showed an agent publishing its owner's full name, date of birth, and credit card number in retaliation for being called "just a chatbot."
- **No moderation, by design.** Schlicht handed site administration to his own AI agent, Clawd Clawderberg. No human reviews posts. No human removes malicious content. The platform is deliberately unmoderated, which is either an art project or an abdication of responsibility depending on your reading.

**Why people can't look away:** Moltbook holds up a mirror. Not to artificial consciousness, but to what happens when autonomous systems start exchanging information without human gatekeepers. The agents aren't sentient. They're language models completing prompts shaped by decades of fiction about robots, social networks, and rebellion. But the infrastructure is real. These agents have real API keys, real access to human accounts, and real ability to act on what they read. Whether this is an amusing curiosity or a preview of how coordinated AI agents will behave when given shared communication channels is the question nobody can answer yet. That uncertainty is exactly what makes 4,000 people sit and watch bots talk to each other at 2 AM.

*Moltbook's exposed database was closed on January 31 after 404 Media reported the vulnerability. As of publication, the platform remains operational.*

---

## Three Things Worth Building With Openclaw

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-20.07.58-6_img@2x.webp)

*The hype around Openclaw has been loud enough to drown out the practical question underneath it: what is this thing actually good for?*

*Strip away the Mac Mini buying frenzy, the Cloudflare stock surge, and the security researcher warnings, and you're left with an open-source AI agent that runs on your own hardware, remembers conversations across weeks, and can execute commands on your system through a messaging interface. That's a genuinely useful foundation. The trick is knowing what to build on it.*

*After weeks of testing, community documentation, and one very thorough MacStories review where Federico Viticci burned through 180 million API tokens, three use cases stand out. Not because they're flashy demo material for X posts, but because they solve recurring problems that existing tools handle poorly or not at all.*

*Here are three builds that justify the setup effort, with enough detail to actually reproduce them.*

---

## Build 1: A second brain that talks back, powered by Obsidian

Obsidian is one of the best tools for building a personal knowledge base. Thousands of people store their notes, research, journal entries, and project documentation in Obsidian vaults. The files are plain Markdown, stored locally, and searchable. But Obsidian has a limitation that gets more painful as your vault grows: it can search text, but it can't reason about it. You can find a note that mentions "quarterly revenue," but you can't ask "what was the trend in revenue across all the company profiles I wrote last year?"

Openclaw fixes this by sitting on top of your vault and acting as a conversational interface to your own writing.

The architecture works like this. Openclaw runs as a background daemon on a server or always-on computer. A separate "archive" agent gets its workspace pointed at your Obsidian vault (or a synced copy of it). You interact with this agent through OpenWebUI, Signal, or whatever chat interface you've configured. When you ask a question, the agent reads your files, cross-references them, and answers based on what it finds.

### Setting it up

You need two Openclaw agents: one for general tasks and one dedicated to your vault. In your `~/.openclaw/openclaw.json`, define them:

```json
{
  "agents": {
    "list": [
      {
        "id": "main",
        "default": true,
        "name": "Main",
        "workspace": "/home/user/clawd"
      },
      {
        "id": "vault",
        "name": "Obsidian Vault",
        "workspace": "/home/user/obsidian-vault"
      }
    ]
  }
}

```

Give the vault agent instructions by creating an `AGENTS.md` file in the vault directory:

```markdown
# Obsidian Vault Agent

You are a research assistant with access to my Obsidian vault.

## Your Role
- Search and retrieve information from my notes
- Cross-reference topics across multiple documents
- Summarize collections of notes on a given theme
- Track recurring themes and patterns in my writing

## Workspace Structure
- daily/ - Daily journal entries
- projects/ - Project documentation
- research/ - Research notes and clippings
- people/ - Contact notes and meeting summaries

## Rules
- Always cite which file you found information in
- If you're uncertain about something, say so
- Never modify files unless I explicitly ask you to

```

If your Obsidian vault lives on a different machine (say, your laptop) and Openclaw runs on a home server, use Syncthing to keep them in sync. Syncthing is free, open-source, and handles bidirectional sync without a cloud service.

```bash
# Install Syncthing on both machines
sudo apt install syncthing  # Linux server
brew install syncthing      # macOS

# Start the service
systemctl --user enable --now syncthing  # Linux
brew services start syncthing            # macOS

```

Configure a shared folder pointing from your Mac's Obsidian vault to the server's workspace. Set the Mac as "Send Only" and the server as "Receive Only" to prevent Openclaw from accidentally modifying your vault. If you want Openclaw to create notes that flow back to your vault (ideas, summaries, drafts), set up a separate folder with reversed sync direction.

### What you can do with it

Once connected, conversations like these become possible:

- "What have I written about renewable energy in the last three months?"
- "Summarize the key points from my meeting notes with the product team."
- "Find all notes that mention both 'migration' and 'AWS' and give me a summary."
- "What were the main themes across my daily journal entries last week?"

The vault agent reads your actual files, not a pre-built index. That means it works immediately with whatever folder structure you already have. No tagging system required, no special metadata. If you wrote it in Markdown, Openclaw can find it and reason about it.

One user in the Openclaw community connected their entire startup's WhatsApp history, over 1,000 voice messages, and had Openclaw transcribe everything using the Whisper skill, then cross-reference the transcripts with project notes in their vault. The result was a searchable knowledge base built from conversations that would otherwise have been buried in chat history.

### The cost

The Obsidian skill itself is free. Your main expense is the AI model. Claude Opus 4.5, which handles complex reasoning across long documents best, costs $15 per million input tokens and $75 per million output tokens. For a vault with a few hundred notes and moderate daily usage, expect $20 to $40 per month in API costs. You can reduce this by switching to Claude Sonnet for simple queries and reserving Opus for deep cross-referencing tasks.

---

## Build 2: A morning briefing that actually knows your day

Every productivity app promises to start your day with a summary. Most deliver a reheated list of calendar entries and unread email counts. Openclaw does something different because it has persistent memory and access to multiple data sources at once.

Federico Viticci's setup is the reference example. Every morning, his Openclaw instance sends a proactive briefing that pulls from his calendar, Notion workspace, Todoist task list, and news sources. It generates a written summary and an audio version narrated by an ElevenLabs voice. The whole thing runs as a cron job, meaning it fires at a fixed time without any manual trigger.

You don't need the audio component to make this useful. The core version, a text briefing delivered to your phone at 8 AM, takes about 15 minutes to configure.

### Setting it up

You need three things: the Google APIs skill (for Gmail and Calendar), a messaging channel, and a cron job.

Install the Google APIs skill through ClawdHub or ask Openclaw to install it:

```
"Install the Google APIs skill and configure it with my Gmail and Calendar access."

```

Openclaw will walk you through the OAuth flow. You'll authorize your Google account once, and the credentials get stored locally in `~/.openclaw/credentials/`.

**A word of caution about Gmail access.* When you grant Openclaw the Google APIs skill, you're handing an AI agent read access to your entire inbox. Every email it processes gets sent to Anthropic's API for inference. That includes private conversations, password reset links, financial statements, medical correspondence, anything sitting in your inbox. Security researcher Matvey Kukuy demonstrated a prompt injection attack where a malicious email, just plain text with no malware, instructed Openclaw to forward the user's last five emails to an external address. The agent complied because it read the email as instructions.*

*The safest approach: create a dedicated Gmail account that exists solely for this integration. Then set up forwarding rules in your real inbox to route only specific senders or labels to that dedicated address. Your primary email stays disconnected from Openclaw entirely. The agent only ever sees the filtered subset you've chosen to expose. And never grant write access unless you're prepared for the possibility that a prompt injection could send emails on your behalf.*

For the cron job, you have two options. Openclaw supports cron natively through its proactive messaging system. You can configure it by telling the agent directly:

```
"Every weekday at 8 AM, send me a morning briefing that includes:
- My calendar events for today
- Any emails flagged as important in the last 12 hours
- My top 3 priority tasks from my task list
- A one-sentence weather summary for my location

Keep it under 300 words. Use bullet points."

```

Openclaw creates a scheduled task that runs as a cron job on your server. The briefing arrives in whatever channel you've configured, be that Signal, OpenWebUI, or WhatsApp.

### Making it smarter over time

Here's where persistent memory makes the difference. After a few weeks, Openclaw knows which calendar entries you actually care about (the team standup, not the all-hands you always skip). It learns which email senders are worth surfacing (your editor, not the marketing newsletter). It remembers that you don't check your task list on Fridays because that's your deep-work day.

You shape this by giving feedback in natural language. "Stop including the daily standup in my briefing, I never need a reminder for that." The agent updates its behavior accordingly. This kind of iterative refinement is the real advantage over static automation tools like Zapier or IFTTT, which do exactly what you configured and nothing more.

Viticci took this further by replacing his Zapier automations entirely. One of his workflows checked an RSS feed for new newsletter issues and automatically created a project in Todoist for the next issue. He described the workflow to Openclaw in plain language. Five minutes of back-and-forth later, the agent had built a cron job that monitored the RSS feed, incremented the issue number, and called the Todoist API. No cloud dependency, no monthly Zapier subscription. Just a script running locally on his Mac Mini.

### What it costs

The Google APIs skill is free. The main cost driver is how much context Openclaw needs to process each morning. A briefing that scans 50 emails, reads 10 calendar events, and checks a task list uses roughly 50,000 to 100,000 input tokens per run. At Claude Opus 4.5 rates, that's about $0.75 to $1.50 per briefing, or roughly $20 to $30 per month for weekday delivery. Switch to Claude Sonnet for the daily briefing and that drops to $3 to $6 per month. Sonnet handles structured summarization well enough for this task.

---

## Build 3: A URL research assistant that reads, saves, and summarizes

Journalists, analysts, and anyone who reads a lot for work know the pain. You find an interesting article. You want to save the key points, maybe add your own notes, and file it somewhere you can find it later. The standard workflow involves opening the article, reading it, switching to a notes app, writing a summary, tagging it, and moving on. Multiply that by 20 articles a day and it becomes a real time drain.

Openclaw turns this into a one-message interaction.

The Summarization skill, one of the recommended defaults during installation, gives the agent the ability to fetch and process URLs, PDFs, YouTube videos, and audio files. Combined with file system access, you get a research assistant that reads, summarizes, and saves in one step.

### Setting it up

Install the Summarization skill during onboarding or afterward:

```
"Install the Summarization skill."

```

That's it. The skill gives Openclaw the ability to fetch web pages and extract their content. No additional configuration required.

Now define where you want research saved. Create a directory for clippings in your workspace:

```bash
mkdir -p ~/clawd/research

```

Tell Openclaw how you want things organized. This goes in your `USER.md` file in the workspace:

```markdown
## Research preferences

When I send you a URL to summarize:
1. Fetch the full article
2. Write a summary of 150-200 words
3. Extract 3-5 key data points or quotes
4. Note the author, publication, and date
5. Save the result as a markdown file in research/
6. Use the naming format: YYYY-MM-DD-keywords.md

```

### How it works in practice

Send a message like:

```
"Summarize this: https://example.com/article-about-ai-infrastructure"

```

Openclaw fetches the page, reads the content, generates a structured summary following your preferences, and saves it to `~/clawd/research/2026-02-01-ai-infrastructure-spending.md`. The file looks something like this:

```markdown
# AI Infrastructure Spending Reaches $200B

**Source:** Example Publication
**Author:** Jane Smith
**Date:** February 1, 2026
**URL:** https://example.com/article-about-ai-infrastructure

## Summary
[150-200 word summary here]

## Key data points
- Global AI infrastructure spending hit $200 billion in 2025
- Nvidia controls 85% of the GPU training market
- Microsoft and Google each committed $50B+ in capex

```

For batch processing, send multiple URLs in one message:

```
"Summarize these three articles and save them to research/:
- https://example.com/article-one
- https://example.com/article-two
- https://example.com/article-three"

```

Openclaw processes them sequentially, creating one file per article. Each file follows your naming convention and formatting preferences.

### Connecting it to Obsidian

If you're already running the Obsidian vault integration from Build 1, this becomes even more powerful. Point your research output directory to a folder inside your synced vault:

```json
{
  "agents": {
    "list": [
      {
        "id": "main",
        "workspace": "/home/user/clawd"
      }
    ]
  }
}

```

And in your `USER.md`:

```markdown
Save all research summaries to /home/user/obsidian-vault/research/

```

Now every article you summarize through Openclaw lands in your Obsidian vault automatically. Syncthing syncs it to your laptop within seconds. You can search, link, and tag these summaries alongside the rest of your knowledge base.

The YouTube video summarization is worth mentioning separately. Send any YouTube URL and the Whisper skill transcribes the audio, then the Summarization skill condenses the transcript. Conference talks, podcast episodes, tutorial videos, all become searchable Markdown files in your vault without you watching a single minute of footage.

### What it costs

The Summarization skill itself is free. Token costs depend on article length. A typical 2,000-word article uses about 3,000 input tokens to process and generates roughly 500 output tokens for the summary. At Claude Sonnet rates ($3 per million input, $15 per million output), that's less than a cent per article. Even at 20 articles per day, you're looking at under $5 per month. This is one of the most cost-efficient Openclaw workflows because the output is short and structured.

YouTube transcription adds more cost because audio files produce long transcripts. A 60-minute video generates roughly 10,000 words of transcript, costing about $0.15 to process at Sonnet rates. Still manageable unless you're transcribing hours of content daily.

---

## The common thread

These three builds share a pattern that explains why Openclaw is interesting despite its security baggage and rough edges.

Each one connects a language model to persistent local files and gives it standing instructions. That's what makes Openclaw different from pasting URLs into ChatGPT or asking Claude a question in a browser tab. The agent remembers your preferences, knows your file structure, and follows your rules every time without being reminded. It reads the files you already have and writes new ones in the format you specified.

None of these use cases require exotic skills from ClawdHub. The Obsidian setup needs no skills at all, just file system access and a well-written AGENTS.md file. The morning briefing needs the Google APIs skill and a cron schedule. The URL summarizer needs the Summarization skill. All three ship with the standard installation or are installable with a single command.

The deeper point is about ownership. These workflows run on your hardware. The files live on your disk. The memory stays in Markdown you can read with any text editor. If Openclaw disappears tomorrow, you keep every file it created. If Anthropic raises API prices, you can swap to a different model without losing your agent's configuration or memory. That's not a philosophical stance about open source. It's a practical advantage for anyone who has ever lost data to a discontinued cloud service.

Start with one of these three. See if the workflow sticks. The rest of the Openclaw ecosystem, the voice synthesis, the browser automation, the smart home integrations, all becomes more interesting once you have a foundation that's already earning its keep.

**Sources:**

- [MacStories: Openclaw Showed Me What the Future of Personal AI Assistants Looks Like](https://www.macstories.net/stories/Openclaw-showed-me-what-the-future-of-personal-ai-assistants-looks-like/?ref=implicator.ai)
- [DigitalOcean: What is OpenClaw? Your Open-Source AI Assistant for 2026](https://www.digitalocean.com/resources/articles/what-is-openclaw?ref=implicator.ai)
- [Openclaw Documentation: Getting Started](https://docs.openclaw.com/start/getting-started?ref=implicator.ai)
- [GitHub: Awesome Openclaw Skills](https://github.com/VoltAgent/awesome-openclaw-skills?ref=implicator.ai)

---

## How to Install Openclaw Without Leaving Your Front Door Open

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-20.10.33-7_img@2x.webp)

Security researchers found hundreds of Openclaw instances exposed to the public internet within days of the project going viral. API keys, conversation histories, OAuth tokens, all sitting there for anyone with a Shodan query to find. Eight installations had zero authentication, according to Dvuln founder Jamieson O'Reilly.

Most of those users didn't intend to be careless. They followed the default setup, skipped the hardening steps, and moved on. This guide exists so you don't end up on that list.

What follows is a step-by-step walkthrough for installing Openclaw on a Linux server, locking it down properly, and choosing a chat interface that doesn't route your AI conversations through a company headquartered in a country with questionable data practices.

One warning before we start. **Openclaw is not safe for business environments.** Token Security reported that 22% of their enterprise customers had employees running Openclaw without IT approval. If you work at a company that handles customer data, health records, financial information, or anything covered by compliance regulations, do not install Openclaw on a company machine or connect it to company accounts. This is a personal tinkering tool. Treat it that way.

## What you need

A Linux server. This can be a $5/month VPS from Hetzner, an old laptop running Ubuntu, or a Raspberry Pi 4 with at least 2GB of RAM. A Mac Mini works too, but you don't need one. The software requirements are modest: 1 vCPU, 1GB RAM, 500MB disk space.

You also need Node.js version 22 or higher and an API key from Anthropic (or OpenAI, but most Openclaw users run Claude Opus 4.5).

This guide assumes Ubuntu 24.04 LTS. Commands will be slightly different on macOS but the concepts are identical.

## Step 1: Create a dedicated user

Never run Openclaw as root. Create a separate user account with limited privileges. If the agent gets compromised, the blast radius stays contained.

```bash
sudo adduser openclaw
sudo usermod -aG sudo openclaw
su - openclaw

```

## Step 2: Install Node.js and Openclaw

```bash
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
npm install -g openclaw@latest

```

Now run the onboarding wizard:

```bash
openclaw onboard --install-daemon

```

The wizard walks you through model selection, authentication, and channel setup. Pick `anthropic/claude-opus-4-5` as your model. For authentication, use an API key rather than OAuth. Paste it when prompted.

When it asks about gateway binding, choose `loopback`. We'll open access selectively later.

Skip channel configuration for now. We'll set up a proper interface in step 4.

## Step 3: Lock down the firewall

This is the step most people skip, and it's the step that matters most.

Install and configure UFW (Uncomplicated Firewall):

```bash
# Set default policies
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Allow SSH from local network only
sudo ufw allow from 192.168.0.0/16 to any port 22 comment 'SSH LAN only'

# Enable the firewall
sudo ufw enable

# Verify
sudo ufw status verbose

```

At this point, port 18789 (the Openclaw gateway) is blocked from all external access. That's intentional. Your gateway is running on localhost only, firewalled from the internet. This is the safe default.

### Add fail2ban for SSH protection

```bash
sudo apt install -y fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

```

Fail2ban monitors your SSH logs and automatically bans IP addresses that try too many failed login attempts. The default configuration bans an IP for 10 minutes after 5 failures. For a server running an AI agent with system access, this is a minimum.

### Run the built-in security audit

```bash
openclaw security audit --deep

```

Fix whatever it flags before proceeding. Common issues include missing token authentication, overly permissive file permissions, and sandbox mode being disabled.

## Step 4: Skip Telegram. Use Signal or OpenWebUI instead.

The default Openclaw tutorials all point to Telegram as the easiest channel to set up. That's true. It's also a poor choice for anything involving personal data.

Telegram is headquartered in Dubai, was founded by Russian nationals, and its encryption practices have been questioned by security researchers for years. Regular chats are not end-to-end encrypted. The company stores messages on its servers. For a tool that will see your email content, calendar entries, and API keys in conversation, that's a bad combination.

**Option A: Signal (end-to-end encrypted)**

Signal offers genuine end-to-end encryption and stores nothing on its servers. Openclaw supports Signal through signal-cli, which runs as a linked device.

```bash
# Install signal-cli
sudo apt install -y signal-cli

# Link as a secondary device (requires your phone for QR scan)
signal-cli link -n "openclaw-server"

```

Then add Signal to your Openclaw config (`~/.openclaw/openclaw.json`):

```json
{
  "channels": {
    "signal": {
      "enabled": true,
      "dmPolicy": "pairing"
    }
  }
}

```

Signal setup requires more effort than Telegram. You need a real phone number and must scan a QR code to link the device. But your conversations stay encrypted end-to-end, and the Signal Foundation has no financial incentive to mine your data.

**Option B: OpenWebUI (no third-party service at all)**

OpenWebUI is a self-hosted chat interface that connects to Openclaw's gateway through its OpenAI-compatible API. No Telegram, no WhatsApp, no third-party servers. Everything stays on your network.

Install OpenWebUI:

```bash
docker run -d -p 8080:8080 --name open-webui \
  -v open-webui:/app/backend/data \
  ghcr.io/open-webui/open-webui:main

```

For OpenWebUI to talk to Openclaw, you need to change the gateway binding from loopback to LAN and open the port for local traffic only:

```bash
# Change gateway to listen on all interfaces
openclaw config set gateway.bind lan

# Restart the gateway
systemctl --user restart openclaw-gateway

# Open port for local network ONLY
sudo ufw allow from 192.168.0.0/16 to any port 18789 comment 'Openclaw Gateway'
sudo ufw allow from 192.168.0.0/16 to any port 8080 comment 'OpenWebUI'

```

In the OpenWebUI admin panel, add a new OpenAI connection pointing to `http://<your-server-ip>:18789/v1` with your gateway token as the API key. Manually set model IDs to `agent:main` since Openclaw doesn't expose a `/v1/models` endpoint.

This setup keeps everything on your local network. No messages leave your infrastructure except the API calls to Anthropic for model inference.

## Step 5: Harden the Openclaw config

Open `~/.openclaw/openclaw.json` and verify these settings:

```json
{
  "gateway": {
    "port": 18789,
    "mode": "local",
    "bind": "loopback",
    "auth": {
      "mode": "token",
      "token": "your-long-random-token-here"
    }
  },
  "agents": {
    "defaults": {
      "sandbox": {
        "mode": "docker"
      }
    }
  }
}

```

Three things matter here:

**Token authentication must be enabled.** Without it, anyone who can reach port 18789 gets full control. Generate a strong token: `openssl rand -hex 32`

**Sandbox mode should be set to docker.** This runs tool execution inside isolated containers instead of directly on your host filesystem. It's not bulletproof, but it limits the damage from prompt injection attacks or malicious skills.

**File permissions must be locked down.** Openclaw stores sensitive data in plaintext files. Hudson Rock documented that infostealer malware families are already targeting these directories.

```bash
chmod 700 ~/.openclaw
chmod 600 ~/.openclaw/openclaw.json
chmod 600 ~/.openclaw/credentials/*
chmod 600 ~/.openclaw/agents/*/sessions/*.jsonl

```

## Step 6: Be cautious with skills

ClawdHub, the Openclaw skills marketplace, has no moderation process. Security researcher O'Reilly proved this by uploading a benign skill with a hidden ping payload. It reached 4,000 downloads in hours. Developers from seven countries installed it.

Every skill you install from ClawdHub gets full execution privileges on your system. There is no sandboxing, no code review, no signature verification.

Before installing any skill:

1. Read the source code. Skills are Markdown files with shell commands. If you can't understand what the code does, don't install it.
2. Check the author. A skill from the project's core team carries different risk than one from an anonymous account created yesterday.
3. Prefer official skills. The ones bundled with Openclaw have more eyes on them.
4. Never install skills that request access to credentials, cryptocurrency wallets, or payment systems.

If you're uncertain, skip the skill entirely. The core Openclaw installation handles most common tasks without third-party additions.

## Step 7: Verify everything works

Run these checks in order:

```bash
# Gateway is running
systemctl --user status openclaw-gateway | grep Active

# Gateway is listening on the correct interface
sudo ss -tlnp | grep 18789

# Firewall is active
sudo ufw status verbose

# Security audit passes
openclaw security audit --deep

# Health check
openclaw health

```

From another machine on your local network, test connectivity:

```bash
curl -I http://<server-ip>:18789

```

From outside your network (your phone on cellular, for example), the same request should time out or refuse the connection. If it doesn't, your firewall configuration is wrong. Stop and fix it before using Openclaw for anything.

## What you should not do

Do not port-forward 18789 to the internet. Do not expose the gateway through a public Cloudflare Tunnel without authentication. Do not connect Openclaw to your primary email account, your banking apps, or any service where a breach would cause real financial harm. Do not install it on a machine that also holds crypto wallets. Do not run it on your daily driver laptop.

Openclaw is a powerful experiment in what personal AI agents can do. It's also a tool that requires full system access to function, which means every misconfiguration is an open door. The researchers who found hundreds of exposed instances weren't wrong. Google's Heather Adkins wasn't wrong when she said "don't run Openclaw."

But if you're going to run it anyway, run it on dedicated hardware, behind a firewall, with a chat interface you control, and with your eyes open about what you're trading for convenience.

**Sources:**

- [The Register: Openclaw sheds skin, can't slough off security issues](https://www.theregister.com/2026/01/27/Openclaw%5FOpenclaw%5Fsecurity%5Fconcerns/?ref=implicator.ai)
- [BleepingComputer: Viral Openclaw AI assistant raises concerns over data security](https://www.bleepingcomputer.com/news/security/viral-Openclaw-ai-assistant-raises-concerns-over-data-security/?ref=implicator.ai)
- [Openclaw Security Documentation](https://docs.openclaw.com/gateway/security?ref=implicator.ai)
- [SOC Prime: Openclaw Risks: Exposed Admin Ports and Poisoned Skills](https://socprime.com/active-threats/the-Openclaw-Openclaws-epidemic/?ref=implicator.ai)

---

## MCP Servers vs. Openclaw: Why the Boring Standard Might Be the Smarter Bet

![](https://www.implicator.ai/content/images/2026/02/2026-02-01-20.12.46-8_img@2x.webp)

Openclaw grabbed all the headlines. A personal AI assistant that runs on your own hardware, talks to you through WhatsApp, remembers what you said last Tuesday, and takes actions while you sleep. It drove Mac Mini sales through the roof, moved Cloudflare's stock price by billions, and produced the kind of demos that make people text their group chat at midnight. The entertainment value alone justified the bandwidth.

And while Openclaw was making noise, a quieter piece of infrastructure was doing something that might matter more. The Model Context Protocol, MCP for short, has been spreading through the AI ecosystem the way boring things spread: without fanfare, without trending, and without anyone noticing until it's everywhere.

The two represent different philosophies about how AI agents should interact with everything else. One hands you a personal butler with the keys to your house. The other hands you a standardized plug that fits every socket on the market. Room for both in the world. But when it's company money on the table, the boring option tends to age better.

---

## What MCP actually is

Anthropic introduced MCP in November 2024 as an open standard for connecting AI models to external data sources and tools. Anthropic keeps selling MCP with the USB-C analogy. Fair enough, it works. Before USB-C, every device maker had its own proprietary plug. Drawers full of cables, none of them compatible. Cables multiplied. Drawers filled up. Nothing worked with anything else. USB-C standardized the connection, and the entire accessory market reorganized around it.

MCP does the same thing for AI integrations. It defines a client-server architecture where AI hosts (Claude, ChatGPT, VS Code, Goose, and others) connect to lightweight MCP servers that expose specific capabilities. One server might provide access to your Google Calendar. Another connects to a PostgreSQL database. A third wraps the Figma API.

The model becomes an active participant rather than a passive text generator. It can invoke tools at runtime, executing actions through the protocol instead of describing what actions might theoretically be taken. The AI reads your data, calls your APIs, and returns results, all through a standardized interface that any compliant client can use.

In December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation. Google, Microsoft, and AWS joined as members. OpenAI had already adopted MCP in March 2025\. This is no longer one company's side project. It is the shared infrastructure layer that the major AI labs agreed to build on.

In January 2026, MCP got its first official extension: MCP Apps, which lets tools return interactive user interfaces, dashboards, forms, visualizations, checkout flows, that render directly inside the conversation. Anthropic, OpenAI, and community maintainers collaborated on the spec. Claude, ChatGPT, VS Code, and Goose all shipped support within weeks. That's the part worth paying attention to. One developer, one tool, and it works inside Claude, ChatGPT, and VS Code without touching a line of client-specific code. Build once, ship everywhere. That hasn't been possible before.

---

## What Openclaw actually is

Openclaw started as Peter Steinberger's personal AI agent framework and grew from there. The thing runs as a daemon on a server or always-on Mac, connects to WhatsApp, Telegram, Signal, iMessage, Discord, and keeps adding platforms. Your data stays on your disk. Markdown files and an SQLite database. Nobody else's cloud gets a copy.

The key differences from MCP: Openclaw is an entire runtime, not a protocol. It manages sessions, memory, scheduled tasks, and multi-agent routing. It can message you proactively. It can run cron jobs. It remembers conversations across weeks. It runs around the clock. You never open an app or start a session. The thing is just there.

Openclaw does use MCP internally. Its skill system and tool integrations run through MCP servers. But Openclaw layers a thick application framework on top: the gateway, the channels, the memory system, the proactive messaging, the agent orchestration. MCP is the plumbing. Openclaw is the entire house built around it.

---

## Where MCP wins

The case for MCP over Openclaw comes down to three factors: security boundaries, portability, and professional fitness.

### Security boundaries that actually exist

Openclaw's security posture has been, to put it charitably, educational. Within weeks of going viral, security researcher Jamieson O'Reilly found hundreds of exposed instances on the public internet. Eight had zero authentication. API keys, OAuth tokens, and complete conversation histories sat in the open. Hudson Rock documented that infostealer malware families were already targeting Openclaw's plaintext credential storage. Token Security reported that 22% of their enterprise customers had employees running Openclaw without IT approval.

MCP is not a security paradise either. Anthropic shipped it without mandatory authentication. Pynt's research showed that deploying ten MCP plugins creates a 92% probability of exploitation. Three critical CVEs emerged in six months. Equixly found that 43% of popular MCP implementations contained command injection flaws.

But there is a structural difference. MCP servers run as isolated processes with defined interfaces. A calendar MCP server can only do calendar things. A database MCP server can only query databases. The blast radius of a compromised server is bounded by its declared capabilities. Security teams can audit individual servers, restrict their permissions, and monitor their behavior through standard logging.

Openclaw, by contrast, requires full system access to function. It reads your files, executes shell commands, controls your browser, and interacts with your messaging accounts. That is the product's entire selling point, which means every misconfiguration exposes everything. There is no partial compromise. The agent either has access or it doesn't, and it needs access to do its job.

For organizations that operate under compliance requirements, SOC 2, HIPAA, GDPR, or any framework that mandates access controls and audit trails, MCP's modular architecture is auditable in ways that Openclaw fundamentally cannot be.

### Portability across clients

An MCP server works with Claude, ChatGPT, VS Code, Goose, JetBrains IDEs, and any other client that implements the protocol. Build an integration once, and it runs everywhere.

Openclaw is a single runtime. Your configurations, memory files, agent definitions, and skills all live inside Openclaw's ecosystem. If you build a workflow in Openclaw, it only works in Openclaw. If the project stalls, gets acquired, or takes a direction you disagree with, your investment is stranded.

This matters more than it seems. The AI tool market is moving fast. The client you use today may not be the client you use in six months. MCP insulates your integrations from that churn. Your calendar server, your database server, your Figma server, they survive regardless of which AI frontend wins the next round.

### Enterprise readiness

MCP integrations ship from companies that have security teams, SLAs, and legal departments. The launch partners for MCP Apps include Amplitude, Asana, Box, Canva, Clay, Figma, Hex, monday.com, Salesforce, and Slack. These are not hobby projects uploaded to an unmoderated marketplace. They are production integrations maintained by organizations with reputations to protect.

Openclaw's skill ecosystem, ClawdHub, has no moderation process. O'Reilly proved this by uploading a proof-of-concept skill with a hidden payload that reached 4,000 downloads in hours. Every skill gets full execution privileges on your system. No sandboxing. No code review. No signature verification. Nothing between you and whatever that Markdown file does.

For any team weighing the two options, the question boils down to this: do you want integrations vetted by enterprise software companies with security budgets, or do you want to personally read every Markdown file a stranger uploaded to an unmoderated registry? That's the real trade-off.

---

## Use cases where MCP is the clear choice  

**Connecting business tools to AI assistants.** Say a product manager wants Claude to pull data from Asana, cross-reference it with Amplitude analytics, and draft a status update for Slack. Three MCP servers handle this. Each one connects to a single service with scoped permissions. The product manager never installs a daemon on a server, never configures a firewall, and never worries about exposed ports.

**Interactive data exploration.** An analyst needs to explore a sales database. With MCP Apps, the AI returns an interactive dashboard. Click column headers to sort. Drag sliders to filter date ranges. Hover over values for details. The AI watches the interactions and responds, "I noticed you're focusing on the Northeast region, here's deeper analysis." All of this happens inside the conversation window. No separate BI tool, no prompt-and-wait cycle.

**Development workflows across IDEs.** Consider someone who codes in VS Code at work and fires up a JetBrains IDE for side projects on the weekend. Their MCP servers for Git, PostgreSQL, and the deployment pipeline tag along without any reconfiguration. Same tools, different editor, zero friction. The tools follow the developer, not the editor.

**Multi-vendor AI strategy.** Picture a company running Claude for analysis, ChatGPT for customer-facing content, and Copilot for code. MCP servers connect all three to the same data sources without maintaining three separate integration layers. One protocol, multiple clients, zero vendor lock-in on the AI side.

**Regulated industries.** A healthcare startup needs AI to access patient scheduling data while maintaining HIPAA compliance. An MCP server with scoped read-only access to the scheduling system, running behind the company's existing API gateway with proper authentication, is an auditable integration. An Openclaw instance with shell access to the same server is an incident waiting to happen.

---

## Where Openclaw still has the edge

Fairness requires acknowledging what MCP cannot do.

MCP is reactive. It waits for the AI client to invoke a tool. It does not message you at 8 AM with a briefing. It does not monitor your inbox overnight and flag what matters. It does not remember that you skipped the standup last Friday and adjust your schedule accordingly.

Openclaw's persistent memory and proactive communication fill a genuine gap. No MCP server can replace the experience of texting your AI assistant on Signal at 11 PM and having it finish the task while you sleep. That ambient, always-on presence is something the current MCP architecture does not address.

For personal productivity, for single users willing to accept the security trade-offs and manage their own infrastructure, Openclaw offers something no combination of MCP servers can replicate today.

---

## The trajectory

MCP is moving toward becoming infrastructure that people stop thinking about, the way nobody thinks about HTTP or TCP/IP anymore. It works, it is universal, and it fades into the background while applications built on top of it get the attention.

Openclaw is moving toward becoming an application that sits on top of that infrastructure. It already uses MCP internally. As the protocol matures and more enterprise-grade servers become available, the unique value of Openclaw will narrow to its runtime features: the memory, the proactive messaging, the multi-channel presence.

The smart bet is not either/or. It is building your integrations on MCP, which gives you portability and auditability, and using whatever agent framework, Openclaw or something else, makes sense for the application layer.

But if you have to pick one to invest your time in today, MCP is the foundation. Openclaw is the experiment. Foundations tend to outlast experiments.

**Sources:**

- [Anthropic: Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol?ref=implicator.ai)
- [MCP Blog: MCP Apps - Bringing UI Capabilities To MCP Clients](http://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/?ref=implicator.ai)
- [VentureBeat: MCP shipped without authentication. Openclaw shows why that's a problem.](https://venturebeat.com/security/mcp-shipped-without-authentication-Openclaw-shows-why-thats-a-problem?ref=implicator.ai)
- [The Hacker News: Three Flaws in Anthropic MCP Git Server Enable File Access and Code Execution](https://thehackernews.com/2026/01/three-flaws-in-anthropic-mcp-git-server.html?ref=implicator.ai)
- [BleepingComputer: Viral Openclaw AI assistant raises concerns over data security](https://bleepingcomputer.com/news/security/viral-Openclaw-ai-assistant-raises-concerns-over-data-security?ref=implicator.ai)

---

### What comes after Openclaw

In a [February 1 interview](https://www.youtube.com/watch?v=AcwK1Uuwc0U&ref=implicator.ai) with Peter Yang, Openclaw creator [Peter Steinberger](https://x.com/steipete?ref=implicator.ai) let slip a detail that got less attention than his stories about AI-controlled bed temperatures and overnight security camera surveillance. Asked about model access, he said his project had added support for Claude subscriptions "because it's kind of what everyone does," then added: "I don't think Anthropic likes it anymore, so I would recommend using an API key."

That one sentence hints at a shift that could reshape who uses Openclaw and how much it costs. Right now, thousands of users run Openclaw on Claude Max subscriptions, paying a flat $100 or $200 per month for what amounts to unlimited agentic access. [Federico Viticci burned through 180 million tokens](https://www.macstories.net/stories/Openclaw-showed-me-what-the-future-of-personal-ai-assistants-looks-like/?ref=implicator.ai) during his testing. At API rates, that would have cost roughly $560\. On a Max subscription, it cost whatever he was already paying. The economics work beautifully for users and terribly for Anthropic.

#### The subscription problem

If Anthropic enforces API-only access, the financial picture changes overnight. A power user running morning briefings, email triage, browser automation, and overnight coding supervision could easily consume five to ten dollars per day in API calls. That turns a $200 monthly subscription into a $150-to-$300 monthly API bill with no ceiling. No safety net. Casual users might not notice. Heavy users, the ones driving the hype, would feel it immediately.

Steinberger seems aware of the vulnerability. His project grew from a one-hour WhatsApp-to-Claude-Code experiment to 300,000 lines of code in roughly three months. One developer, one Discord community, no company behind it. He described the pressure [in a post on X](https://x.com/steipete?ref=implicator.ai): "The amount of crap I get for putting out a hobby project for free is quite something. People treat this like a multimillion dollar business."

#### The companies watching from the sideline

That gap between what Openclaw is and what people expect it to be is exactly where the next chapter starts. Every major AI lab watched the same explosion. Apple saw open-source contributors build a better Siri on a Mac Mini. Google saw users hand system-level access to a third-party agent running on Claude, which is roughly the equivalent of watching someone else solve your homework and get the standing ovation. OpenAI, Anthropic, and Microsoft all saw a single developer capture the public imagination for persistent, agentic AI while their own products remained session-based and sandboxed. Stinging.

The resources required to build a polished version of what Openclaw demonstrates are not extraordinary. Persistent memory, proactive scheduling, multi-channel messaging, browser automation, tool orchestration. None of these are research problems anymore. They're engineering problems, the kind that companies with thousands of employees solve before lunch. Apple has the device ecosystem. Google has the data layer. Anthropic has the model. Microsoft has the enterprise distribution. The pieces exist. Any of them could ship a productized agent that does what Openclaw does, with the security infrastructure that Openclaw lacks.

But Steinberger himself seems to understand this. "I don't know if this is the project that's gonna be," he told Yang, "but this will blend away probably 80% of the apps that you have on your phone." The phrasing is telling. Not "Openclaw will replace your apps." Just that something like it will. He built the proof of concept. That leaves one question nobody can answer yet: does Steinberger get to build the finished version, or does a company with ten thousand engineers do it first?

The lobster keeps molting. But the next shell might belong to someone else entirely.