The AI Agent Parity Race

Three announcements landed in the same week in March 2026. NVIDIA released NemoClaw, an enterprise-grade wrapper around OpenClaw. Anthropic shipped Claude Cowork Dispatch, which lets you message an AI agent from your phone and come back to finished work on your computer. And OpenClaw's creator, Peter Steinberger, was settling into his new role at OpenAI after joining in February, with the project now living under an open-source foundation.

Each announcement approached the same problem from a different direction: how to give people AI agents that are useful, persistent, and secure enough for real work. Days later, Anthropic added Claude Code Channels, bringing Discord and Telegram messaging into the same local agent architecture. Within five weeks, three major players independently converged on remarkably similar answers, and the pace hasn't slowed down.

The question worth asking isn't which framework wins. It's what enterprise IT leaders should actually be paying attention to instead.

OpenClaw, NemoClaw, and Claude Dispatch: What Each One Does

OpenClaw started the conversation. It's an open-source agent that runs locally, connecting large language models to your actual software: your files, your browser, your command line. It went viral in early 2026. It also exposed 42,000 instances with critical authentication vulnerabilities, which is why every subsequent entry in this space leads with security.

NemoClaw is NVIDIA's answer, announced at GTC on March 16. It wraps OpenClaw with enterprise privacy and security controls using NVIDIA's Agent Toolkit and OpenShell for policy-based guardrails. It's hardware-agnostic (it doesn't require NVIDIA GPUs) and integrates with NVIDIA's NeMo framework for model training and deployment. The pitch is straightforward: OpenClaw's capabilities with enterprise-grade guardrails.

Claude Cowork Dispatch, announced March 17, takes a different approach entirely. Instead of wrapping an existing agent framework, Anthropic built a persistent conversation that runs on your computer and accepts tasks from your phone. Files stay local, execution happens in a sandbox, and you approve what the AI touches before it acts.

Claude Code Remote Control, shipped in February, is the complementary piece: it bridges your local Claude Code terminal session to any device, keeping your full environment (MCP servers, tools, filesystem) available while you work from a browser or phone.

And just this week, Anthropic shipped Claude Code Channels, which pushes the pattern further: MCP servers that forward Discord and Telegram messages directly into a running Claude Code session. You message a bot, it lands in your agent's context, and Claude can reply back through the same channel. If that sounds familiar, it should. Multi-channel messaging was one of OpenClaw's original draws (WhatsApp, Slack, Discord, iMessage, Signal). Anthropic just rebuilt the capability with local execution and scoped permissions baked in from the start.

OpenAI hasn't shipped a direct competitor yet, but Steinberger's move there in February signals where they're heading. OpenClaw stays open source under a foundation, while OpenAI presumably builds on the same patterns for their own agent infrastructure.

Why Early Claude Dispatch Reviews Are Missing the Point

Early reviews of Dispatch describe it as unreliable, with roughly a coin-flip success rate on tasks. The computer has to stay awake, and execution is slow.

I think the criticism is aimed at the wrong thing.

These are research preview problems, not architectural problems, and most of them are shared across every early agent tool, including OpenClaw. The computer-must-be-awake constraint and the slow execution are engineering problems being worked on across the industry right now. They will be solved on a timeline measured in weeks and months, not years.

What matters is the pattern Dispatch establishes: persistent, locally-executed, mobile-dispatched, sandbox-controlled. That pattern is the correct end state for professional AI agents. The data stays on your machine, and the agent works within boundaries you set. You can hand off a task while you walk to a meeting and review the result when you sit down. The fact that it works roughly half the time today tells you very little about where it will be in six months.

The same principle applies to the whole landscape. These tools are architecturally different today. OpenClaw is closer to browser automation, NemoClaw wraps it with enterprise governance, and Claude Dispatch is native LLM orchestration. They solve different problems at different layers. But they're all converging on the same user experience: an AI agent that runs locally, connects to your tools, persists across sessions, and works within explicit permissions.

Don't evaluate them by what they do today. Evaluate them by the pattern they're establishing, because the pattern is what reaches parity.

The AI Agent Governance Gap

The common framing is that organizations are slow to adopt AI agents. The evidence says the opposite.

The evidence is everywhere: 42,000 exposed OpenClaw instances, power users wiring Claude to task management tools via personal API keys, teams building custom agent skills on personal accounts outside the boundaries of any official system. Adoption isn't the problem. People want these tools and they're not waiting for permission.

The problem is that organizations can't govern what they didn't plan for. And every one of these agents needs something to connect to. An AI that can manage tasks is useless if your task management lives in three separate systems that don't share data. An agent that can draft a meeting briefing needs access to your CRM, your calendar, and your background files, and it needs those systems to share data cleanly enough that the output is worth reading.

MCP (Model Context Protocol) is one answer. Anthropic developed it as an open standard for connecting AI agents to tools, and it's gaining traction. But MCP is a protocol, not a solution. Someone still has to stand up the servers, scope the permissions, map the data flows, and maintain the connections as systems change. That's integration work, and it's the kind of work most organizations have been underfunding for years.

The organizations that will benefit most from AI agents aren't the ones that pick the right framework. They're the ones that have already invested in connecting their systems: clean APIs, consistent data models, and permissions architectures that can express "read access to this project's tasks but not that one's." The agent framework is the last mile. The integration layer is the road.

AI Agents and Shadow IT: Why This Wave Is Different

Shadow IT isn't new. Organizations have been dealing with unauthorized Dropbox accounts, personal Gmail for work, and WhatsApp groups for official communication for over a decade. But AI agents introduce something qualitatively different: they don't just store information outside official channels. They act on it.

An employee using a personal Dropbox stores files in the wrong place. An employee using an AI agent connected to their work tools can create tasks, send messages, modify documents, and make decisions that affect workflows across the organization. The blast radius of ungoverned AI agent use is fundamentally larger than any previous shadow IT wave, and in government and diplomatic contexts, the implications for records management, classification, and security are serious.

Every month that an organization delays building governed integration infrastructure, the gap widens. Shadow IT becomes the default working environment for the most capable people. When the organization eventually does adopt official AI agent tools, it will face the same integration problem it postponed, plus the additional work of migrating whatever the power users built in the meantime.

What Enterprise IT Leaders Should Do Now

If you're an IT leader in a large organization, the question isn't which AI agent framework to adopt. That question will answer itself as the market matures. The question is whether your systems are ready for any of them.

Are your core systems accessible via API? If your task management, CRM, document management, and communication tools can't be accessed programmatically, no agent framework will help. This is the most basic prerequisite, and it's where many organizations still fall short.

Do you have a permissions model that can express granular access? AI agents need the same kinds of permission structures as human employees: access to some things, not others, with clear boundaries. "All or nothing" access models are incompatible with how these agents work.

Is your data clean enough to be useful? An AI agent pulling from a CRM with 40% stale records will produce 40% stale outputs. The processing layer got smarter, but garbage in, garbage out hasn't changed.

Can you see what your people are already doing? The power users aren't waiting. Before you can govern AI agent use, you need to know what's already happening. That conversation is better had with curiosity than with a compliance audit.

The AI agent landscape is going to keep moving. OpenClaw will improve, NemoClaw will mature, and Dispatch will get reliable. Something we haven't heard of yet will launch next month and shift the conversation again.

The integration infrastructure and governance frameworks under your existing systems won't build themselves on that timeline. That's the work worth starting now.

If you want to get ready for using Claude Dispatch or remote Claude Code execution, I wrote a step-by-step guide that walks through getting started.