OpenClaw · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

Mon, 13 Apr 2026 10:00:00 +0300

I’ve always believed in diversification. Don’t marry a single tool. Don’t build your entire workflow around one company’s product. Keep your options open, because today’s darling is tomorrow’s deprecation notice.

I still believe that. And this quarter, Anthropic proved exactly why—in both directions.

They shipped 120+ features in 90 days. Two flagship models. Computer use. Managed agents. A CLI. Connectors to 50+ workplace tools. The most aggressive product execution any AI company has shown. While OpenAI ships quarterly and Google on a similar cadence, Anthropic has been shipping weekly. Sometimes daily.

And then, on April 4, they cut off OpenClaw—the largest open-source AI agent project on GitHub—from using Claude subscriptions. Nine days later, OpenClaw announced they’d moved to GPT-5.4. “Anthropic cut us off. GPT-5.4 got better. We moved on.”

So now you dependent on OpenAI? 🫠 https://t.co/2jnzOlHXch
— Pini (@PiniShv) April 13, 2026

I don’t like putting all my eggs in one basket. But when one basket is riding a wave this big—and simultaneously proving why you shouldn’t trust any single basket—you need to understand what’s happening.

The numbers that matter
#

In 90 days, Anthropic released:

40+ Claude Code updates
15+ Cowork updates
20+ API changes
2 new models (Opus 4.6 and Sonnet 4.6)
Computer use, Dispatch, Connectors, Channels, Remote Control, and a Plugin Marketplace

Their internal team ships 60–100 releases per day. Anthropic engineers now use Claude for roughly 60% of their own work, up from 28% a year ago, reporting ~50% productivity gains. Claude Cowork was built with Claude Code in 10 days.

That last part is worth sitting with. They used their own tool to build a new product in less than two weeks. The compounding flywheel isn’t theoretical anymore. It’s shipping.

On the business side: $380 billion valuation after a $30B Series G in February. Revenue run-rate at $14 billion, growing 10x annually. Over 500 customers spending $1M+ per year. Eight of the Fortune 10 are Claude customers.

This isn’t a startup experimenting. This is a company executing at a pace that’s forcing the rest of the industry to react.

What actually moved the needle
#

I’m not going to do a tier list—you can find those elsewhere. What I want to do is break down the releases that change how developers work, not just what sounds impressive on a changelog.

The model leap: Opus 4.6 and Sonnet 4.6
#

Opus 4.6 dropped February 5 with serious specs: 1 million token context window, 128K max output tokens (doubled from 64K), full adaptive thinking support, 80.9% on GPQA Diamond, 80.8% on SWE-bench verified. The adaptive thinking shift is important—the model now decides how deeply to reason per turn rather than consuming a fixed budget, which makes it more efficient for mixed workloads where some turns need deep reasoning and others don’t.

Sonnet 4.6 followed on February 17, becoming the default for Free and Pro plans. Near-Opus performance at 5x lower cost ($3/M input, $15/M output), 79.6% on SWE-bench. This is the model that matters most for daily use. If Opus is for the hard problems, Sonnet is for everything else—and “everything else” is 90% of the work.

The compaction API (beta, launched alongside Opus) deserves attention too. Server-side context summarization for effectively infinite conversations. If you’ve been building agents that run into context limits during long sessions, this is the fix you’ve been writing workarounds for.

Computer use + Dispatch: AI that does things
#

I wrote about this when it shipped in late March. Claude can now control your Mac—open apps, navigate browsers, fill spreadsheets, submit PRs. Pair it with Dispatch and you assign tasks from your phone while Claude works on your desktop.

The technical model: Claude reaches for the most precise tool first. Calendar request? Google Calendar connector. Slack message? Slack integration. No connector available? It falls back to screen-based control—mouse, keyboard, browser. The permission model is explicit: Claude asks before touching a new application, and Anthropic scans model activations during computer use to detect adversarial prompt injection.

Mac only. Research preview. It will be unreliable for complex workflows. But the jump from “AI that talks about doing things” to “AI that does things” is real. The security implications are the part that keeps me up at night—prompt injection against a computer-controlling agent is a fundamentally different threat than prompt injection against a chat model.

Claude Code: from assistant to development platform
#

Claude Code had the densest quarter of any product line. The headline features:

Remote Control (Feb 24): Supervise Claude Code sessions from your phone via claude.ai/code. Approve or reject changes, monitor long-running tasks without staying at your desk. This changes the workflow from “sit and watch” to “check in when it matters.”

Hooks: Deterministic actions that fire at lifecycle points—session start/end, file changes, tool use. These run 100% of the time, unlike advisory instructions that the model might ignore. This is the automation primitive that makes Claude Code composable with your existing tooling.

Subagents and /simplify: Parallel workers with clean context windows. /simplify distributes agents across changed files for code review, checking for reuse and quality. /batch handles large migration tasks across multiple files. This is multi-agent execution inside a coding tool—the same architectural direction Cursor 2.0 is taking with worktree-based parallelism.

128K output tokens (up from 16K default, 64K max): Quietly massive for code generation. Combined with the 1M token context window, Claude Code can now reason about entire mid-sized production codebases and generate substantial implementations in a single turn.

This isn’t a coding assistant anymore. It’s a development platform with an agent architecture. The Plugin Marketplace, scheduled tasks, voice mode, and MCP elicitation are all infrastructure for a tool that’s meant to run alongside you, not just respond when prompted.

Connectors: the quiet game-changer
#

Connectors might be the most strategically important release of the quarter. Claude now integrates bidirectionally with Gmail, Slack, Notion, Figma, Asana, Google Drive, and 50+ other tools.

Bidirectional. Not just “read your Slack messages.” Claude can modify content in connected applications. That’s the difference between a search engine and a coworker. It’s the same logic behind MCP—give the AI access to your real context—but packaged as a consumer-friendly feature with zero setup friction.

The strategic angle: every connector is a switching cost. Once Claude is wired into your Slack, Gmail, and Notion, moving to a different AI provider means rewiring all of those integrations. Anthropic understands this. The convenience is real, and so is the lock-in.

Managed Agents and the platform play
#

April 7–9 brought the most architecturally significant releases:

Managed Agents (public beta): A fully managed framework for running Claude as an autonomous agent. Secure sandboxing, built-in tools, SSE streaming. Create agents, configure containers, run sessions through the API.
Advisor Tool (public beta): Pairs a fast executor model with a higher-intelligence advisor for strategic mid-generation guidance. A senior engineer reviewing the junior’s work, but as an API parameter.
ant CLI: Command-line client for the API with native Claude Code integration and YAML-based resource versioning.

Managed Agents is the one to watch. Until now, building production agent systems meant stitching together your own sandboxing, tool management, and execution infrastructure. Anthropic just said “we’ll handle that.” That’s a platform play aimed directly at the middleware layer that startups were building. It’s also the kind of move that makes you more dependent on Anthropic’s infrastructure, not less.

The OpenClaw situation
#

And this is where the story gets uncomfortable.

On April 4, Anthropic blocked Claude subscription access for third-party agentic tools, starting with OpenClaw—the open-source AI agent gateway with over 247K GitHub stars. Users on Pro and Max plans can no longer route their subscription through OpenClaw. They must now use pay-as-you-go “extra usage” billing or direct API access.

Boris Cherny, Anthropic’s Head of Claude Code, explained that “subscriptions weren’t built for the usage patterns of these third-party tools.” The technical argument has merit: OpenClaw achieves ~10% cache hit rates compared to Claude Code’s much higher rates, meaning a single $200/month Max subscriber running OpenClaw continuously could consume $1,000–$5,000 in API-equivalent compute. The economics don’t work at all-you-can-eat pricing.

But the optics are terrible. Anthropic shipped Cowork—which does much of what OpenClaw does—and then cut off the open-source competition. Peter Steinberger, OpenClaw’s creator, characterized it as copying features from the open-source project and then locking out the competition. Whether that’s fair or not, it’s the perception.

OpenClaw’s response was swift. Version 2026.4.5 shipped with GPT-5.4 as the recommended default. “Anthropic cut us off. GPT-5.4 got better. We moved on.” They didn’t just switch models—they built new features around GPT-5.4’s native computer use capabilities. One week to migrate an entire project’s recommended provider.

This isn’t just a drama story. It’s a technical lesson about platform dependency:

If you build on a provider’s subscription model, you’re borrowing capacity they can revoke. OpenClaw users discovered overnight that their $200/month subscription wasn’t a contract—it was a courtesy. API access is still available, but at 5–25x the effective cost for heavy agentic workloads.

The switching cost for model providers is lower than we think. OpenClaw migrated to GPT-5.4 in a week. User testing shows comparable performance after prompt tuning. The model layer is commoditizing faster than any single provider wants to admit. The lock-in is in the tooling, the connectors, the workflow—not the model itself.

Open-source doesn’t protect you from upstream decisions. OpenClaw is MIT licensed. 247K stars. Massive community. None of that mattered when Anthropic decided the economics didn’t work. Your code is open, but your dependency on a closed API is still a single point of failure.

This is exactly why I’ve always maintained a multi-provider workflow. And it’s exactly why Anthropic’s execution makes that stance so conflicted—the tools are genuinely excellent, and using them means accepting the platform risk.

The compounding flywheel (and why it’s hard to ignore)
#

The features are impressive individually. What actually matters is the pace.

Anthropic released a major Claude update roughly every two weeks in 2026. Agent Teams and Opus 4.6 shipped the same week. Code Review landed on a Monday, and by Friday they’d added 1M context GA and four more Claude Code features.

This isn’t speed for speed’s sake. It’s compounding. Each feature makes the next one faster to build, because the team building them uses the tools they’re shipping. That flywheel is the real competitive advantage—not any individual model or feature.

The developer experience data reflects this. Claude Code works first try 91% of the time on feature generation, versus 78% for GPT-5 and 65% for Gemini 2.0.

But speed has costs. The Claude Code source leak happened during this sprint—a packaging error that shipped internal source code. When you’re publishing 60–100 internal releases daily, the boring parts of the pipeline need to be bulletproof. They’re clearly not yet.

And context fragmentation remains unsolved. For all 120+ features shipped, Claude still loses memory across conversations. You can’t hand off a complex multi-day project between sessions without significant re-prompting. The compaction API helps for single long conversations, but the cross-session problem persists.

The basket question
#

Back to my eggs.

I use Cursor. I use Claude. I use ChatGPT when it’s better for the task. I keep my eye on Gemini’s 2M context window, on GitHub Copilot’s agent mode, on what open-source alternatives like OpenClaw (a self-hosted AI agent gateway that routes through your messaging channels instead of a browser tab) are doing—especially now that they’ve demonstrated you can switch providers in a week.

I’m not going all-in on any single provider. After the OpenClaw situation, I’m more certain of that than ever.

In practice, that means most of my daily work runs through Cursor with Claude as the model layer—it’s the best developer experience I’ve found. But my MCP setup is provider-agnostic by design, my prompts don’t rely on Claude-specific quirks, and I keep ChatGPT and Gemini warm for the tasks where they’re genuinely better. If Anthropic changes the economics tomorrow, I want the migration to be a settings change, not a rewrite.

But I’d be dishonest if I didn’t acknowledge what’s happening. Anthropic in Q1 2026 didn’t just ship features. They demonstrated a development velocity that no competitor has matched. They’re eating their own cooking and the compounding is visible. They went from the company behind “the other chatbot” to the company that developers talk about in the same breath as their core infrastructure.

The guys at Anthropic are on the wave. And the OpenClaw story is a reminder that waves carry things—they don’t let you steer.

The question for developers isn’t whether to use Claude. It’s how to use the best tools available without becoming dependent on any one of them. Build your workflows so the model layer is swappable. Keep your context portable. Treat every provider’s pricing model as temporary. And pay close attention to what Anthropic is building—because right now, they’re building faster than anyone else.

Diversification doesn’t mean ignoring the best tools available. It means using them without letting them own you.

What’s your setup? All-in on Claude, spreading your bets, or actively building provider-agnostic workflows? Find me on X, Telegram, or LinkedIn.

OpenClaw Is Not a Chatbot. It's a Personal Agent Gateway.

Thu, 19 Mar 2026 14:00:00 +0200

Think about how you use AI right now.

You open a browser tab. You go to ChatGPT or Claude. You type something. You get a response. You close the tab. Tomorrow you open it again and start from scratch. Maybe you remember to use Projects. Maybe you don’t.

Now think about how you communicate with your actual team. WhatsApp. Telegram. Slack. Discord. You don’t open a special app to talk to people. You message them wherever you already are, and the conversation continues across devices and time zones.

OpenClaw is built on a simple bet: your AI assistant should work the same way. Not in a browser tab. In the places you already are. Always on, always reachable, always remembering what you talked about yesterday.

That sounds like a small UX difference. It’s not. It changes what an AI assistant can actually do for you.

What OpenClaw actually is
#

Let me be clear about what this is and what it isn’t. The project’s own FAQ is blunt: it is not “just a Claude wrapper.”

OpenClaw is a self-hosted gateway that connects AI agents to your messaging channels. WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, WebChat. Plus a browser Control UI and companion apps for macOS, iOS, and Android.

The GitHub repo has roughly 325k stars, which makes it one of the largest open-source AI projects out there. But the star count isn’t the interesting part. The interesting part is the architecture.

The Gateway is the single source of truth for sessions, routing, and channel connections. It embeds the Pi SDK directly instead of shelling out to a subprocess, which lets it inject custom tools, tune prompts by context, persist sessions, rotate auth profiles, and switch model providers on the fly. On top of that, ACP (Agent Communication Protocol) lets it hand work off to external coding-agent runtimes when that makes more sense.

In plain English: OpenClaw is not one model with one UI. It’s a routing and orchestration layer that sits above models, tools, channels, and state. The assistant is the product. The Gateway is the infrastructure.

Why this is different from browser-based AI
#

I wrote about Open WebUI recently. Open WebUI moves the AI interface from a vendor’s SaaS into your own self-hosted browser workspace. That’s valuable. But OpenClaw takes a different bet entirely.

Open WebUI says: “The browser is the right interface. You just shouldn’t rent it from OpenAI.”

OpenClaw says: “The browser isn’t the right interface at all.”

That’s a much bolder claim. And honestly, when you think about how people actually interact with technology throughout the day, it makes sense. You’re not sitting in front of a browser all day. You’re in WhatsApp with your family and friends, in Slack with your org, in Telegram with your communities. The browser tab is where you go when you have a dedicated task. Messaging is where you live.

An AI assistant that lives in your messaging layer can do things a browser tab can’t. It can remind you about something at 3pm without you opening an app. It can respond in a group chat where multiple people are coordinating. It can wake up on a schedule and check something for you. It’s persistent in a way that a browser session never is.

What it can actually do
#

The capability surface is broader than “AI in WhatsApp.” Five things matter.

It lives where you are. WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage. You message it like you’d message a person. It responds in the same channel. It works across devices because the Gateway is always running.

It can switch models on the fly. The docs list 35+ providers: Anthropic, OpenAI, Google, OpenRouter, Ollama, vLLM, and any OpenAI-compatible or Anthropic-compatible endpoint. You can route different conversations to different models. Need a quick answer? Local model. Need deep reasoning? Claude. Same conversation thread, different backends.

It can do things, not just answer questions. The tool inventory includes command execution, browser automation, web search, image and PDF handling, cron jobs, and device node controls. The distinction between cron jobs and heartbeat turns is important: it can both run scheduled tasks and periodically wake itself up to surface something relevant. This isn’t autocomplete. This is an agent with hands.

It remembers. Memory is Markdown files in the workspace. Daily logs in memory/YYYY-MM-DD.md, curated long-term memory in MEMORY.md, exposed through memory_search and memory_get. Sessions can be isolated per agent, workspace, peer, or channel. The fact that memory is plain files you can inspect and edit is philosophically consistent with the local-first story and way more transparent than the hidden memory layers in ChatGPT or Claude.

It can extend itself. ClawHub is the public skill registry. Skills are instruction bundles built around SKILL.md files, while tools are typed capabilities the agent gets to use. Discover, install, publish, version, update. The extension model feels like package management for agent capabilities.

How people actually use it
#

The official showcase clusters around patterns that tell you exactly what OpenClaw is good for.

Browser automation without APIs. PR review feedback delivered in Telegram. School meal and grocery ordering. Accounting intake from emailed PDFs. Slack auto-support. Infrastructure and deployment work. Health assistants. 3D printer and home automation. Voice bridges. One person built and shipped an iOS app from Telegram.

The center of gravity is not generic Q&A. It’s persistent coordination across personal and work systems.

Independent anecdotes on Hacker News point the same direction. One user described using OpenClaw to recover and rebuild a media server, diagnose drive failure, and migrate 1.5TB of data. Another said it became a useful participant in a group chat, tracking personalities and helping the group plan together. These are anecdotes, not benchmarks. But they align: the real appeal is infrastructure, automation, and ongoing conversational context.

The hard truth about running it
#

Here’s where I need to be honest, because the community is tired of puff pieces about OpenClaw and so am I.

Setup is real work. Node, API keys, permissions, channel configurations, operational judgment. This is not “download an app and start chatting.” It’s closer to setting up a production service. The people who love OpenClaw are comfortable with that. The people who bounce off it were expecting something simpler.

Local-only is possible but expensive. The docs are unusually blunt about this. OpenClaw expects large context windows and strong prompt-injection resistance. It recommends the strongest latest-generation model available. Serious local setups may require hardware on the level of multiple maxed-out Mac Studios or equivalent GPU rigs. That’s a big reality check against the “runs privately on my old laptop” narrative.

Token costs can surprise you. Users report it’s easy to accidentally create expensive workflows, especially with naive model defaults. An always-on assistant that wakes up on schedules and processes conversations across multiple channels burns tokens constantly. Without cost controls, your monthly bill can go places you didn’t expect.

The security model is honest but limited. The supported posture is one trusted operator boundary per gateway. This is not hostile multi-tenant isolation. OpenClaw ships a security audit CLI, publishes a MITRE ATLAS-based threat model with 37 identified threats (6 critical), and added VirusTotal scanning for published skills. A high-severity CVE was patched in February 2026. The project is actively fixing real vulnerabilities, which is a good sign. But the docs are explicit that none of this makes the system “secure in all respects.”

Skills are code running in your agent’s context. This is the deepest concern. Skills have access to tools and data. The project’s own security documentation explicitly lists risks: exfiltration, unauthorized commands, sending messages on your behalf, downloading external payloads. You are not installing a chatbot. You are delegating action to an always-on agent with real permissions. Treat it accordingly.

Who’s behind it
#

Peter Steinberger is the creator. The project credits Mario Zechner as the creator of Pi (the underlying agent framework) and names several core contributors. It’s MIT licensed.

There’s an interesting governance story here. Steinberger’s blog says he joined OpenAI on February 14, 2026, and that OpenClaw would move to a foundation while remaining open and independent. I found the announcement but not enough public material to treat the foundation transition as fully completed. Worth watching.

The naming history is also telling. The project went through multiple names. Anthropic asked them to reconsider the earlier “Clawd” branding. It went through “Moltbot” before landing on “OpenClaw.” That chaotic evolution says something about how fast this space moves and how young the project still is, despite its star count.

How it compares to the incumbents
#

Versus ChatGPT. ChatGPT gives you a polished hosted product with Projects, scheduled Tasks, and MCP-based custom apps. OpenClaw gives you self-hosting, provider neutrality, and an assistant that lives in your own messaging channels instead of OpenAI’s browser product. ChatGPT wins on zero-ops convenience. OpenClaw wins on control and communication surface.

Versus Claude. Claude now bundles Projects, Artifacts, Research, and Skills inside Anthropic’s managed environment. That makes it the best native Claude experience. OpenClaw is interesting when you want Claude-level intelligence inside your own channels and control plane rather than inside Anthropic’s product. Different layer, different bet.

Versus Gemini. Gemini’s advantage is ecosystem gravity. Deep Research across Search, Gmail, Drive, NotebookLM. OpenClaw’s advantage is ecosystem neutrality. It sits above many providers and your own devices instead of locking the assistant layer to Google.

How it compares to open-source alternatives
#

OpenClaw spans two categories that are usually separate, which makes direct comparisons tricky.

Open WebUI and LibreChat are stronger as self-hosted browser-based AI workspaces. They unify providers, support agents and MCP, and feel like replacements for the mainstream chat products. OpenClaw’s bet is different: move the assistant out of the browser entirely and into your messaging stack, with an always-on gateway and device nodes.

n8n sits on the other flank as an automation platform. Stronger for deterministic workflows, visual orchestration, and integration breadth. OpenClaw is stronger when you want a persistent assistant you can casually message, with memory, channel presence, and agent-like coordination. n8n automates flows. OpenClaw tries to become the thing you talk to.

What this means
#

The broader pattern is the same one I see across AI tooling right now. The model layer is commoditizing. The interface layer is where the real fight happens. And the interface layer is splitting into at least three bets:

Vendor-hosted SaaS (ChatGPT, Claude, Gemini). Maximum convenience, minimum control. The default for most teams today.

Self-hosted browser workspaces (Open WebUI, LibreChat). Same browser paradigm, but you own it. The infrastructure play.

Communication-layer agents (OpenClaw). Not a workspace at all. An assistant that lives where you already are. The most radical bet.

OpenClaw is the most ambitious of the three. It’s also the highest-maintenance, the highest-risk, and the one that requires the most trust. You’re not just self-hosting a UI. You’re running an always-on agent with real permissions inside your real communication channels.

For power users and tinkerers who are comfortable with that, OpenClaw is one of the most interesting projects in the AI space right now. For everyone else, it’s worth understanding as a signal of where AI assistants are heading. Even if you never install it, the question it raises is the right one: why does your AI assistant live in a browser tab when you don’t?

Running personal AI agents? Tried OpenClaw or something similar? I’d love to hear your setup. Find me on X or Telegram.

OpenClaw · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

The numbers that matter #

What actually moved the needle #

The model leap: Opus 4.6 and Sonnet 4.6 #

Computer use + Dispatch: AI that does things #

Claude Code: from assistant to development platform #

Connectors: the quiet game-changer #

Managed Agents and the platform play #

The OpenClaw situation #

The compounding flywheel (and why it’s hard to ignore) #

The basket question #

OpenClaw Is Not a Chatbot. It's a Personal Agent Gateway.

What OpenClaw actually is #

Why this is different from browser-based AI #

What it can actually do #

How people actually use it #

The hard truth about running it #

Who’s behind it #

How it compares to the incumbents #

How it compares to open-source alternatives #

What this means #