OpenClaw
The TypeScript Agent Runtime with the Biggest Community
The highest-starred agent harness project has an event model worth stealing and a community worth joining. It also has a blind spot that matters more than most people realize.
Yesterday I wrote about Hermes Agent, the runtime that treats skill accumulation as a first-class concern. Today I need to talk about the other anchor in this space: OpenClaw, at roughly 385,000 GitHub stars and counting. If Hermes is the runtime that compounds, OpenClaw is the runtime that connects. The distinction defines which one you pick and why.
OpenClaw is a TypeScript-first personal agent harness. You install it, configure a model provider, connect a chat platform, and you have an always-on agent that lives wherever you run it. Telegram, Discord, Slack, WhatsApp, Signal, iMessage, Microsoft Teams, Matrix, LINE, and more. The platform list alone signals the architectural bet: everything is a channel. Every message, every cron tick, every webhook event, every heartbeat flows through the same unified input queue. The agent doesn’t know or care whether a request came from a Telegram DM at 3 AM or a scheduled automation firing on its cadence. That abstraction, treating everything as an event, is the right one. Most agent frameworks bolt scheduling and messaging on as separate subsystems. OpenClaw makes them the same thing.
The event model produces architectural clarity that cascades through the whole system. Session rewind and branching, introduced in the latest releases, lets you fork a conversation from any message and explore alternative paths without losing the original thread. MCP Apps can be hosted inside the agent, pinned to dashboards, and opened from channel replies. Questions and approvals flow across web, desktop, mobile, and Wear OS surfaces with a consistent interaction model. The runtime ships with guided setup that detects local inference providers, offers downloadable models, and even runs llama.cpp in-process for privacy-sensitive deployments. The scope is immense, and the architecture holds it together because everything is built on the same event primitive.
The current version as of this writing is v2026.7.2-beta.7, released August 2. The jump from beta.3 at planning time to beta.7 two weeks later is itself a signal: this project ships frequently, and the recent work is substantial. State safety and recovery got quarantine stores, crash-recoverable SQLite snapshots, and rollback-writer snapshot recovery. Durable channel delivery now means messages accepted on Telegram, Signal, Slack, Discord, and eight other platforms survive gateway restarts and local crashes. Native apps expanded to Linux with signed updates. Meeting plugins for Teams, Zoom, and Google Meet are enabled by default. A Wear OS companion lets you select models and control realtime Talk from your wrist. This is not a project coasting on star count. It’s a project shipping infrastructure that makes agents actually persistent across failure boundaries.
The community is the other thing that’s hard to replicate. At 385,000 stars, OpenClaw has roughly 74% more GitHub engagement than Hermes Agent and an order of magnitude more than LangGraph. The contribution graph is active. The release notes, as you may have gathered from the wall of text I just referenced, are comprehensive. The npm package serves as the distribution channel, and the plugin ecosystem around ClawHub gives the runtime an extensibility model that most agent harnesses lack. When you build on OpenClaw, you’re building on a platform with the largest surface area in the category.
Here is the blind spot, and it’s the one that matters most for the argument I’m making this month.
OpenClaw does not learn from experience. Every session starts fresh. The agent doesn’t remember what worked last time and adjust its approach. It doesn’t accumulate skills that compound with use. It doesn’t have a self-improvement loop where the runtime itself gets more capable the more you run it. It persists state. It recovers from crashes. It keeps running. But it doesn’t get better at running.
This is not a bug. It’s an architectural choice, and it’s a defensible one. OpenClaw optimizes for broad platform support, TypeScript ecosystem integration, and a unified event model that makes every interaction feel like the same agent regardless of which channel initiated it. A self-improvement loop would add complexity to that event model that might compromise the abstraction it works so hard to maintain. The tradeoff is real: broad connectivity versus compounding capability. OpenClaw chose connectivity.
The question is whether you can afford to choose connectivity over compounding for a personal agent that you expect to use every day. If your primary need is an agent that’s available everywhere, that answers on Telegram while you’re commuting and on Slack while you’re working, that joins your Zoom calls and takes notes, that runs on your phone and your wrist and your desktop, OpenClaw is the best option available. No other runtime matches its platform coverage. The event model makes adding new channels coherent rather than bolted-on. The community means plugins, documentation, and ecosystem momentum that smaller projects cannot match.
If your primary need is an agent that gets smarter over time, that remembers which debugging approaches worked for your codebase and which documentation patterns you prefer, that accumulates a library of proven workflows rather than starting from scratch every session, you want Hermes Agent. That was yesterday’s post. The two runtimes are not competitors in the sense that one is objectively better. They optimize for different things, and the overlap between those things is smaller than it looks.
The honest assessment is that OpenClaw’s blind spot, the absence of a self-improvement loop, becomes more expensive the longer you use it. In month one, the platform coverage and event model are transformative. In month six, the agent still doesn’t know your preferences unless you’ve hardcoded them into a system prompt. In month twelve, the gap between an agent that compounds and an agent that connects has widened into a chasm. The runtime that seemed more capable at the start, because it was everywhere, turns out to be the one that plateaued.
That said, OpenClaw’s architectural decisions are the right ones for a lot of teams. If you’re building in TypeScript, if your users need broad platform support, if you want an event-driven model that treats scheduling, messaging, and webhooks as the same abstraction, the project delivers. The durability work in the latest releases, the crash recovery, the dead-letter handling for channel messages, suggests the team understands that persistence is not just about surviving restarts. It’s about trust. An agent that sometimes loses messages is an agent nobody relies on. OpenClaw ships the infrastructure to make that trust earned rather than claimed.
The runtime layer of the agent ecosystem is still forming. Hermes and OpenClaw are the two leading open-source projects, and they represent two different bets about what matters most. OpenClaw bets on breadth: be everywhere, connect everything, make the event model so clean that adding a new platform is a plugin rather than a project. Hermes bets on depth: accumulate skills, learn from experience, make the agent better at being an agent the longer it runs. The right choice depends on whether your agent’s value comes from where it can reach or what it can learn.
If you’re building this right now, pick the bet that matches what your agent actually needs to become over time. The platform coverage is impressive today. The question is whether it will still be the thing that matters in six months.
If this was useful, forward it to one engineer who needs less noise in their feed.