What Are AI Claws? Persistent Autonomous Agents Explained (2026)

AI claws are persistent autonomous agents that loop independently, maintain sophisticated memory, and act on your behalf even when you are not looking. The term emerged from Andrej Karpathy's March 2026 interview on the No Briars podcast, where he described the next evolution beyond AI agents — systems that own their sandbox, communicate through messaging protocols, and replace entire categories of software with natural language interfaces.

This is not a theoretical concept. Karpathy's personal claw, Dobby, already controls his smart home — Sonos speakers, lights, HVAC, security cameras — all through WhatsApp. No apps. No dashboards. Just natural language.

The claw represents a fundamental shift in how humans interact with software. And no one has written the definitive guide yet. This is it.

TL;DR: AI claws are persistent autonomous agents that run independently with memory, tool access, and messaging interfaces — the layer above agents in Karpathy's hierarchy. His Dobby claw replaced 6 smart home apps with WhatsApp commands. Taskade Genesis Workspace DNA mirrors claw architecture with Memory + Intelligence + Execution. Build your own →

What Are AI Claws?

AI claws are persistent autonomous agents that own their sandbox environment, run continuous loops independently, and communicate with humans through messaging protocols like WhatsApp. Karpathy defines them as the consumer-ready layer above agents — systems deployed on personal hardware that act on your behalf without requiring active supervision. The term "claw" distinguishes these systems from session-based AI agents by emphasizing persistence, autonomy, and real-world tool integration.

In Karpathy's hierarchy, the progression is clear: LLMs are the raw primitive. Agents are semi-finished products that execute tasks within a session. Claws are the consumer-ready deployment that loops independently on personal hardware. And beyond claws lie swarms — distributed networks of autonomous agents collaborating across machines.

The key distinction is persistence. An agent runs when you invoke it and stops when the task completes. A claw runs continuously. It monitors, reacts, learns, and executes — whether you are watching or not.

"It kind of like does stuff on your behalf even if you're not looking." — Andrej Karpathy

This persistence changes everything about how software works. Instead of opening six different apps to control your smart home, you send a WhatsApp message to your claw. Instead of manually checking security cameras, your claw watches them and alerts you when something changes. Instead of configuring automation rules across disconnected platforms, your claw orchestrates everything through natural language.

The implications extend far beyond smart homes. Claws represent the architecture for agentic workspaces that run entire business operations autonomously — monitoring data, triggering workflows, coordinating multi-agent systems, and evolving through accumulated context.

The Agent-to-Claw Evolution

The AI capability stack follows a clear hierarchy where each layer builds on the previous one, adding more autonomy, persistence, and coordination. Understanding where claws fit in this stack is essential for building effective AI systems in 2026.

Each layer in this hierarchy represents a phase change in capability:

Layer 1 — LLMs (raw primitive): The foundation. A language model takes text in and produces text out. No memory between calls. No tools. No persistence. This is what ChatGPT was at launch — powerful but stateless.

Layer 2 — Agents (semi-finished): Agents add tool use, reasoning chains, and session-level memory. Claude Code was what Karpathy calls "the first convincing demonstration of what an LLM Agent looks like." Agents can read files, write code, run commands, and iterate on results — but they stop when the session ends. This is the layer that powered vibe coding and the agentic engineering revolution.

Layer 3 — Claws (consumer-ready): Claws add persistence, autonomous loops, sophisticated memory, and communication interfaces. They run on personal hardware, own their sandbox, and operate continuously. Karpathy's Dobby is the canonical example. This is the current frontier.

Layer 4 — Swarms (distributed): Multiple claws collaborating across machines, organizations, and trust boundaries. Karpathy's distributed auto-research vision — where untrusted compute pools contribute experiments that trusted verifiers validate — points toward this layer. "The Earth is much bigger and has a huge amount of untrusted compute."

Karpathy describes the acceleration of this hierarchy:

"The LLM layer is taken for granted. The agent part is taken for granted. Now claws are taken for granted. Now you can have multiple of them, instructions to them, and optimization over the instructions."

The progression from agents to claws mirrors the progression from scripts to daemons in traditional computing. A script runs once and exits. A daemon runs continuously in the background, monitoring events and responding autonomously. Claws are AI daemons — persistent, autonomous, and always on.

Karpathy's Dobby: The First Famous Claw

Dobby is Andrej Karpathy's personal claw that controls his entire smart home through WhatsApp messages. It is the most detailed public case study of a working claw system, and it demonstrates why claws will replace entire categories of consumer software.

Karpathy built Dobby to replace six separate smart home apps — each with its own interface, login, and workflow — with a single natural language interface. The result is a system that discovered devices autonomously, reverse-engineered their APIs, and now controls everything from music to security cameras through conversational commands.

What Dobby Controls

The Discovery Story

The most remarkable aspect of Dobby is how it discovered and integrated with devices. Karpathy did not manually configure APIs or write integration code. He told the agent to find his Sonos system, and the agent:

1. Performed an IP scan of the local network
2. Identified the Sonos device (which had no password protection)
3. Reverse-engineered the Sonos API
4. Started playing music

"I can't believe I just typed in 'can you find my Sonos?' And suddenly it's playing music."

This happened in three prompts. No documentation reading. No SDK installation. No configuration files. The agent explored the network, found the device, figured out how to talk to it, and started working.

Security Camera Intelligence

Dobby uses a vision model called Quinn to monitor security camera feeds. Instead of streaming video continuously (which would be expensive and slow), Quinn uses change detection — it only processes frames when something in the scene changes. When it detects meaningful activity, it sends a WhatsApp message to Karpathy with a description.

The result: "FedEx truck just pulled up" appears on Karpathy's phone before he even looks outside. This is the claw pattern in action — persistent monitoring, autonomous interpretation, and proactive communication.

The App Replacement Pattern

"I used to use like six apps... Dobby controls everything in natural language."

This is the claw thesis in miniature. Every smart home app — Sonos, Hue, Nest, Ring — is a specialized interface for a narrow function. Each requires its own login, its own UI patterns, its own mental model. A claw collapses all of these into a single conversational interface.

Karpathy describes macro actions that demonstrate this collapse: "Dobby it's sleepy time" triggers all lights off, shades down, thermostat adjusted, and music stopped — across five different device ecosystems, through a single WhatsApp message.

This pattern extends far beyond smart homes. Karpathy predicts that claws will subsume entire categories of software:

"These apps shouldn't even exist... agents kind of crumble them up."

The implication for productivity tools, project management, and business automation is profound. Any workflow that currently requires switching between multiple apps is a candidate for claw consolidation.

How Claws Differ From Agents

Claws are not simply agents that run longer. They represent a fundamentally different architecture with distinct properties around persistence, memory, autonomy, and communication. Understanding these differences is critical for building effective AI systems in 2026.

Persistence Changes Everything

When an agent session ends, its context disappears. The next session starts from scratch (or with a compressed summary). This is why agents feel like tools — you pick them up, use them, and put them down.

A claw never stops running. Its memory accumulates over days, weeks, and months. It learns your patterns. It knows that "sleepy time" means a specific sequence of actions across five device ecosystems. It remembers that you prefer jazz on weekday mornings and electronic music on weekends.

This persistence is what transforms an AI tool into an AI teammate. And it is the same principle behind Workspace DNA — where Memory feeds Intelligence, Intelligence triggers Execution, and Execution creates Memory in a self-reinforcing loop.

The Communication Interface

Agents communicate through APIs, function calls, and terminal output. Claws communicate through human messaging protocols — WhatsApp, SMS, email, chat. This is not a superficial difference. It means claws participate in the same communication channels humans use, making them accessible to non-technical users and integratable into existing workflows.

Karpathy chose WhatsApp for Dobby because it is the messaging app he already uses. No new app to install. No new interface to learn. The claw meets the human where they already are.

This pattern maps directly to how Taskade agents work — embedded in the workspace where teams already collaborate, accessible through natural language, and integrated with the tools and platforms teams already use.

The Claw Architecture: Memory, Persistence, and Autonomy

Building a claw requires four foundational components that work together as a continuous system. Each component addresses a limitation of session-based agents, and together they create something qualitatively different from any individual agent.

1. Sophisticated Memory

Default agent context compaction — where old messages are summarized to fit within the context window — is insufficient for claws. Karpathy emphasizes that claws need memory systems that preserve important information across sessions without lossy compression.

This means structured storage: facts about the environment (device IPs, API endpoints, user preferences), episodic memory (what happened yesterday, what worked and what failed), and procedural memory (how to perform complex multi-step tasks).

The memory requirement is why Workspace DNA's Memory layer — structured projects, databases, and knowledge bases — is architecturally aligned with claw design. A workspace that stores structured data gives agents the persistent memory they need to function as claws.

2. Persistent Execution Loop

A claw runs a continuous loop: observe the environment, check for new instructions, evaluate conditions, decide on actions, execute, update memory, repeat. This loop runs whether the human is present or not.

The loop can be event-driven (react when something changes), scheduled (run at specific times), or instruction-driven (respond to messages). Most claws combine all three modes. Dobby monitors cameras continuously (event-driven), adjusts HVAC on a schedule, and responds to WhatsApp messages as they arrive.

In Taskade's automation system, this maps to workflow triggers — events, schedules, and manual invocations that start execution chains across 100+ integrations.

3. Real-World Tool Access

Claws need the ability to affect the physical and digital world — control devices, call APIs, read and write files, access databases, browse the web. Without tool access, a claw is just a chatbot that runs continuously.

Karpathy's Dobby demonstrates aggressive tool use: IP scanning networks, reverse-engineering APIs, controlling physical devices, processing video feeds. This level of tool access is what makes claws useful and also what makes them dangerous.

Taskade AI agents support this through 22+ built-in tools, custom tool creation, and MCP (Model Context Protocol) for connecting to external services. The integration ecosystem provides pre-built connections to the platforms teams already use.

4. Communication Interface

The communication layer is what makes claws accessible. Instead of requiring users to open a terminal or navigate an app, claws communicate through channels humans already use. WhatsApp, Slack, email, SMS — the claw adapts to the human's preferred interface.

This is also the control plane. Humans send instructions, ask questions, and receive updates through the same messaging interface. The claw becomes a participant in conversations rather than a tool you invoke.

OpenClaw vs NanoClaw: Two Approaches

The claw ecosystem has already split into two philosophical camps: comprehensive platforms and minimal implementations. Karpathy has been vocal about which approach he trusts — and his reasoning reveals important principles for anyone building AI systems.

OpenClaw: The Full-Featured Path

OpenClaw (Peter's project) represents the comprehensive approach. At approximately 400,000 lines of code, it includes five innovations that Karpathy praises:

1. Soul/personality document — defines the claw's identity and behavior patterns
2. Memory system — structured long-term storage beyond context compaction
3. WhatsApp portal — natural language interface through existing messaging
4. Experimentation framework — infrastructure for testing and iterating
5. Good defaults — sensible configuration that works out of the box

The ambition is admirable. But Karpathy has a problem with the scale:

"I'm a bit sus'd about security... giving my private data/keys to 400K lines of vibe-coded monster that is being actively attacked at scale."

Reports of exposed instances, remote code execution vulnerabilities, and supply chain poisoning have validated these concerns. When a claw has access to your local network, API keys, and personal data, the codebase surface area becomes a direct security risk.

NanoClaw: The Minimal Path

NanoClaw takes the opposite approach. Core engine: approximately 4,000 lines of code. Containerized by default. Fully auditable.

Karpathy's preference is clear: a claw that "fits into both my head and that of AI agents." This is not just about readability — it is about verifiability. When the codebase is small enough for a human (or an agent) to audit completely, you can have genuine confidence in what it does and does not do.

The NanoClaw philosophy aligns with a broader principle in agentic engineering: complexity is the enemy of trust. The more code you cannot verify, the more risk you carry. In a system with access to your home network and personal data, that risk is existential.

Which Approach Wins?

Both approaches will persist because they serve different users. OpenClaw serves builders who want maximum capability and are willing to accept security trade-offs. NanoClaw serves builders who prioritize auditability and containment.

The more interesting question is what happens when claw platforms provide the best of both — rich capability within auditable, containerized boundaries. This is the design philosophy behind Taskade Genesis, where complex functionality emerges from a managed platform rather than sprawling custom code.

Building Your Own Claw With Taskade Genesis

Taskade Genesis Workspace DNA is architecturally equivalent to a claw — it implements the same three requirements (persistent memory, autonomous intelligence, real-world execution) within a managed platform that eliminates the security risks of self-hosted claw systems.

Workspace DNA as Proto-Claw

The three pillars of Workspace DNA map directly to claw architecture:

The self-reinforcing loop — Memory feeds Intelligence, Intelligence triggers Execution, Execution creates Memory — is exactly the persistent loop that defines a claw. Each cycle accumulates context, making the system smarter and more capable over time.

From Prompt to Claw in Minutes

With Taskade Genesis, building a claw-like system starts with a single prompt:

1. Describe your system — "Build a customer support workspace that monitors email, categorizes requests, drafts responses, and escalates urgent issues"
2. Genesis creates the workspace — database projects (Memory), trained AI agents with custom tools (Intelligence), automation workflows (Execution), and a published app interface
3. The system runs autonomously — agents monitor triggers, process incoming data, execute workflows, and update memory continuously
4. Iterate through conversation — refine agent behavior, add integrations, adjust automation rules — all through natural language

Over 150,000 apps have been built with Taskade Genesis. Each one is a Workspace DNA system that can function as a managed claw — persistent, autonomous, and continuously improving.

Why Managed Beats Self-Hosted

Self-hosted claws like OpenClaw and NanoClaw require you to manage your own infrastructure, security, updates, and containerization. Karpathy's security concerns about 400K-line codebases apply to any self-hosted system as attack surfaces evolve.

Taskade Genesis handles the infrastructure layer — hosting, security, updates, scaling — while giving you the same architectural primitives: persistent memory, autonomous agents, real-world tool access through 100+ integrations, and natural language control. The platform approach is how claws become accessible to teams that are not running their own servers.

Pricing starts at Free (3,000 credits), with Starter at $6/month, Pro at $16/month (10 users included), and Business at $40/month on annual billing.

The Agent Personality Factor

Karpathy's interview revealed an unexpected dimension of working with AI agents and claws: personality matters more than most builders realize. The way an agent communicates directly affects how effectively humans collaborate with it.

Claude vs Codex: A Personality Study

Karpathy draws a sharp contrast between the two agents he uses most:

On Claude: "Claude has a pretty good personality. It feels like a teammate." He describes Claude's praise as calibrated — it does not over-react to half-baked ideas, but rewards genuinely good ones. "I'm trying to earn its praise, which is really weird."

On Codex: "Very dry. It doesn't seem to care about what you're creating."

This difference matters because claws are persistent. You interact with them daily, across months. A claw with a flat personality becomes a tool you tolerate. A claw with a well-tuned personality becomes a teammate you genuinely collaborate with.

Soul Documents

The claw ecosystem has formalized personality through soul documents — configuration files (often called soul.md) that define an agent's identity, values, communication style, and behavioral boundaries. OpenClaw pioneered this pattern, and it has become a standard component of claw architecture.

A soul document might specify:

• Communication tone (formal, casual, playful)
• Domain expertise and limitations
• When to ask for clarification vs. act autonomously
• How to handle errors and uncertainty
• Relationship to the user (assistant, teammate, advisor)

This maps to how Taskade AI agents are configured — each agent has a defined role, custom instructions, and behavioral parameters that persist across all interactions. The personality is not ephemeral; it is part of the agent's persistent identity.

The Jaggedness Problem

Karpathy identifies a fundamental challenge with current AI:

"I simultaneously feel like I'm talking to an extremely brilliant PhD student who's been a systems programmer their entire life and a 10-year-old."

AI capabilities are jagged — extraordinarily strong in some domains and surprisingly weak in others. Ask a state-of-the-art model to refactor a complex codebase and it performs like a senior engineer. Ask it to tell a joke and it delivers the same joke from five years ago.

This jaggedness occurs because labs optimize models through reinforcement learning in domains with verifiable outcomes — code that compiles, tests that pass. Softer skills like humor, nuance, and knowing when to ask clarifying questions lag because they are outside RL training distribution.

For claw builders, this means designing systems that play to AI strengths (structured reasoning, tool use, pattern matching) while managing weaknesses (ambiguity, creativity, social intelligence). The most effective claws route tasks to the right capability tier rather than expecting uniform brilliance.

Security and Trust: The Claw Dilemma

Claws sit at the intersection of maximum capability and maximum risk. A system that can scan your network, control your devices, access your API keys, and act autonomously is extraordinarily useful — and extraordinarily dangerous if compromised.

Karpathy does not shy away from this tension. His security concerns about OpenClaw apply to the entire claw ecosystem:

"Giving my private data/keys to 400K lines of vibe-coded monster that is being actively attacked at scale."

The Attack Surface Problem

Claws expand the attack surface in several dimensions:

Network access: Claws like Dobby scan local networks, discover devices, and reverse-engineer APIs. A compromised claw has the same network access as the machine it runs on.

API key exposure: Claws need credentials to control devices and access services. These keys are high-value targets stored within the claw's environment.

Persistent execution: Unlike session-based agents that stop, claws run continuously. A compromised claw has unlimited time to exfiltrate data or establish persistence.

Code supply chain: OpenClaw's 400K lines of code include dependencies, and reports of supply chain poisoning demonstrate that this vector is actively exploited.

Mitigation Strategies

Karpathy advocates for the NanoClaw approach — minimal codebases that are fully auditable, containerized by default, with explicit security boundaries. Key principles:

1. Minimize codebase size — every line of code is attack surface
2. Containerize everything — claws should not have direct host access
3. Audit dependencies — supply chain attacks target the long tail of packages
4. Principle of least privilege — claws should only access what they need
5. Verify before trusting — especially for claws built through vibe coding where the builder may not understand every line

The managed platform approach (as implemented by Taskade Genesis) addresses these concerns by design — the platform handles security boundaries, credential management, and execution isolation so individual builders do not have to become security engineers.

For teams evaluating whether to build or buy claw infrastructure, the question is whether the security engineering burden of self-hosting is worth the additional flexibility. For most teams, the answer is no — which is why managed agentic workspaces will capture the majority of the claw market.

What Comes Next: From Claws to Swarms

Claws are not the end of the hierarchy. Karpathy describes a future where individual claws connect into distributed networks — swarms of autonomous agents collaborating across machines, organizations, and trust boundaries.

Distributed Auto-Research

Karpathy's AutoResearch project (30,307 GitHub stars in its first week) demonstrates the pattern. A single agent runs experiments autonomously: propose a code modification, run for exactly five minutes, measure results, commit successes, revert failures, repeat. One hundred experiments overnight. Optimizations discovered that Karpathy missed after two decades of manual tuning.

The distributed version — autoresearch@home — extends this to multiple machines. Agents on different machines claim experiments, publish results (successes and failures), and pull the global best configuration. Coordination happens through a shared memory service.

This is the swarm pattern: autonomous agents contributing to a shared goal without centralized control, verified through objective metrics.

The Untrusted Compute Vision

"The Earth is much bigger and has a huge amount of untrusted compute. Maybe the swarm out there could run circles around Frontier Labs."

Karpathy draws a parallel to blockchain: commits build on each other, proof of work equals expensive experimentation, and verification is cheap. Trusted pools verify results from untrusted contributors. The architecture allows massive parallelism without requiring trust.

This vision extends to any domain with verifiable metrics. Drug discovery, materials science, climate modeling — anywhere you can measure success objectively, swarms of claws could accelerate research by orders of magnitude.

The Software Paradigm Shift

Claws and swarms are part of a broader transformation that Karpathy frames through his Software 3.0 lens:

• Software 1.0: Human-written code
• Software 2.0: Neural network weights (Karpathy coined this in 2017)
• Software 3.0: Prompts as programs — "English is the new programming language"

In the claw era, software becomes "free, ephemeral, malleable, discardable after single use." The will vibe coding kill SaaS debate finds its answer here — not through code generation replacing SaaS, but through claws subsuming the need for individual apps entirely.

"The customer is not the human anymore. It's agents acting on behalf of humans."

This means every software product needs two interfaces: one for humans (GUIs) and one for agents (APIs and plain text like llms.txt). Products that only serve human eyeballs will be disintermediated by claws that access services directly through APIs.

Taskade's approach — providing both human-facing workspace interfaces and agent-accessible APIs with 100+ integrations — positions it for a world where the customer is increasingly an autonomous claw acting on behalf of a human team.

The Skill Issue: Why Human Operators Still Matter

Despite the autonomy of claws, Karpathy is clear that the human operator remains the critical variable. When agents fail to produce results, the limiting factor is almost always the human's ability to decompose tasks, write effective prompts, and orchestrate workflows.

"It all kind of feels like skill issue when it doesn't work. You just haven't found a way to string together what's available."

This framing is important because it counters the narrative that AI will simply automate humans away. Instead, the humans who learn to operate claws effectively — the agentic engineers — gain extraordinary reach. They put in "very few tokens just once in a while and a huge amount of stuff happens on your behalf."

Karpathy describes his own workflow: he has not typed a line of code since December 2025. Instead, he operates multiple parallel agents, each working on separate tasks across different repositories. The developer moves between them, assigning work at the macro level — "here's a new functionality, delegate to agent 1" — rather than writing individual lines.

This is the agentic workspace pattern at scale. The human becomes the orchestrator, the vision holder, the quality reviewer. The claws handle execution. And the competitive advantage goes to whoever orchestrates most effectively.

The 80/20 progression rule Karpathy describes applies here: spend 80% of your time with stable productive setups and 20% exploring the next capability tier. Right now, that means mastering agent workflows while beginning to experiment with claw-level persistence and autonomy. Taskade Genesis provides the platform to do both — build working systems today while the architecture naturally evolves toward full claw autonomy.

Explore the Taskade Community to see what 150,000+ builders have already created, from automated workflows to multi-agent systems to complete agentic workspaces — each one a step toward the claw future Karpathy describes.

FAQ