OpenClaw is an open-source AI agent framework designed for builders who need autonomous, self-hosted software that runs locally on macOS, Linux, or Windows without shipping data to third-party APIs unless explicitly configured. As of April 2026, the framework maintains over 347,000 GitHub stars and serves as the execution layer for thousands of production agents handling everything from automated trading systems to 24/7 content moderation teams. Unlike cloud-only alternatives, OpenClaw gives you the Gateway (central orchestration), Nodes (distributed execution units), Skills (tool collections), and a people-aware Memory layer that tracks provenance and conversation context without external dependencies. This deep dive focuses on the key features of OpenClaw v2026.4.29-beta.3.
What You’ll Accomplish with OpenClaw v2026.4.29-beta.3
By following this guide, you will install OpenClaw v2026.4.29-beta.3, configure the new Codex Computer Use integration with fail-closed Model Context Protocol (MCP) security, enable active-run steering for dynamic automation workflows, and integrate DeepInfra for media generation workloads. You will migrate existing tool configurations to comply with the new explicit security profile requirements and optimize your Gateway startup using manifest-first metadata. This setup provides a production-hardened AI agent infrastructure capable of handling subagent routing, heartbeat-delivered reminders, and multi-channel automation with visible-reply enforcement across Slack, Telegram, Discord, and WhatsApp. This comprehensive configuration ensures robust, secure, and adaptable AI agent deployments.
Prerequisites for OpenClaw Installation
You need a machine running macOS 14+, Ubuntu 22.04+, or Windows 11 with Windows Subsystem for Linux 2 (WSL2). Install Node.js 20 LTS, Docker 25+ for sandboxed execution, and Git for repository management. You need API keys for at least one Large Language Model (LLM) provider such as OpenAI, Anthropic, DeepInfra, or NVIDIA. For Codex Computer Use, you need macOS 15+ with accessibility permissions enabled or a Linux host with X11 forwarding. Ensure your system has a minimum of 8GB RAM, 20GB disk space, and outbound HTTPS access to GitHub for plugin marketplace discovery. If running distributed nodes, open ports 3000-3005 for Gateway communication to facilitate inter-node communication.
Understanding OpenClaw’s Core Architecture in 2026
OpenClaw operates on a distributed architecture where the Gateway manages state while Nodes execute skills in isolated contexts. In the 2026.4.29 release cycle, the architecture shifted toward manifest-first metadata, reducing boot-time provider discovery and enabling faster model catalog reuse across restarts. The Gateway now maintains an event-loop readiness diagnostic that blocks incoming connections until all runtime dependencies report healthy, preventing the race conditions common in v2026.3.x releases. Memory evolved into a people-aware wiki with provenance views, meaning every fact stored links back to its source conversation and participant, enabling audit trails for compliance-heavy deployments. The system uses a unified execution model that eliminated the legacy nodes.run RPC in favor of direct skill invocation, reducing latency by approximately 40ms per call. Channels connect via adapters that now enforce Block Kit limits for Slack, handle Telegram proxy failover, and manage Discord rate-limit backoff automatically.
Installing OpenClaw v2026.4.29-beta.3 from Source
To begin, clone the repository and checkout the specific beta tag to access the latest security patches and Codex integration. Run git clone https://github.com/openclaw/openclaw.git && cd openclaw followed by git checkout v2026.4.29-beta.3. Install dependencies with npm ci --production to ensure exact lockfile compliance and prevent dependency mismatches. For Docker deployments, use docker build -t openclaw:2026.4.29-beta.3 . with the included multi-stage Dockerfile that now supports optional GPU passthrough via --build-arg ENABLE_GPUS=true for accelerated workloads. Verify installation by running ./claw --version, which should output 2026.4.29-beta.3. Initialize your configuration directory with ./claw init --config-dir ./config, which generates the new scaffolded structure including providers.yaml, security.yaml, and the skills.d directory for modular skill definitions.
Configuring Codex Computer Use with Fail-Closed MCP Validation
Codex Computer Use enables desktop control for agents, but v2026.4.27 introduced mandatory fail-closed MCP checks to prevent unauthorized access. This feature is crucial for maintaining a secure environment when agents interact with your operating system. First, install the Codex plugin using the command: ./claw plugin install computer-use --source marketplace. Verify its status with ./claw plugin status computer-use, which reports the current MCP validation state. Next, edit your security.yaml file to enforce strict validation, ensuring robust security protocols.
mcp:
validation:
mode: fail-closed
allowed_origins:
- "https://api.openai.com"
schema_enforcement: strictThis configuration ensures any Model Context Protocol tool failing authentication or schema validation immediately terminates the agent run rather than degrading to a permissive mode. This measure is vital for preventing security vulnerabilities. For macOS users, grant accessibility permissions in System Settings > Privacy & Security > Accessibility to allow the agent to interact with the desktop. Finally, test the configuration with ./claw test mcp --computer-use, which validates the sandbox boundary before allowing screen access, providing an additional layer of security assurance.
Enabling Active-Run Steering for Dynamic Automation Workflows
Active-run steering, now enabled by default in v2026.4.29-beta.3, allows dynamic behavior adjustment during long-running automations. Previously, agents followed static configuration, which could lead to inflexibility. Now, agents evaluate the execution context every 30 seconds to pivot strategies based on real-time conditions. To explicitly enable and configure steering in your agent settings, modify your agent configuration file as follows:
automation:
active_run_steering: true
evaluation_interval: 30s
pivot_strategies:
- timeout_recovery
- channel_switchoverThis feature is essential for messaging automations where, for example, Slack API limits might trigger a fallback to Telegram, or where subagent tasks require rerouting based on intermediate results. The steering engine consumes approximately 150MB RAM per active run but effectively prevents the stuck-agent scenarios common in earlier versions, significantly improving reliability. Monitor steering decisions via claw logs --filter steering to observe real-time pivots and gain insights into your agent’s adaptive behavior.
Implementing Visible-Reply Enforcement Across Channels
Visible-reply enforcement ensures agents never send silent or collapsed messages in channels, maintaining clear and transparent communication. In v2026.4.29-beta.3, this applies by default to all messaging adapters, enhancing user experience and accountability. You can configure per-channel enforcement in your channels.yaml file, allowing fine-grained control over how your agents interact within different communication platforms.
slack:
visible_reply_enforcement: true
block_kit_limit: 50
telegram:
visible_reply_enforcement: true
proxy_failover: trueThe framework now handles Slack Block Kit limits automatically, splitting long responses into threaded replies rather than truncating them, which prevents information loss and improves readability. For Telegram, the system implements robust proxy, webhook, and polling resilience, retrying sends through alternate routes if primary webhooks fail, ensuring message delivery. WhatsApp and Discord adapters have received similar delivery and liveness fixes, guaranteeing your agents maintain conversation visibility even during network partitions or temporary service outages.
Setting Up Subagent Routing Metadata for Distributed Tasks
When spawning subagents, v2026.4.29-beta.3 automatically injects routing metadata to track lineage across distributed nodes, providing a clear audit trail for complex, multi-agent workflows. This metadata is crucial for understanding the relationships and dependencies between various agent tasks. Configure routing in your gateway.yaml file to enable this functionality and specify its behavior:
subagent:
routing_metadata:
enabled: true
propagate_context: true
ttl: 3600sThis metadata includes parent_agent_id, spawn_timestamp, and routing_path, enabling you to trace precisely which Gateway initiated which subtask. When combined with the people-aware memory layer, subagents inherit conversation context without the need for explicit variable passing, simplifying development and improving consistency. Use claw subagent list --show-routing to view active subagent trees with their metadata provenance, which helps in debugging and monitoring. This feature significantly reduces the “orphaned subagent” problem, where distributed tasks lose their parent context during network disruptions.
Configuring Opt-In Follow-Up Commitments and Heartbeat Delivery
The new opt-in follow-up system allows agents to schedule commitment reminders via heartbeat messages rather than persistent polling, significantly reducing resource consumption and improving efficiency. This approach ensures that reminders are delivered only when the agent is actively connected, minimizing unnecessary network traffic and battery drain on mobile nodes. Enable this feature in your agent profile configuration:
commitments:
follow_up:
enabled: true
delivery_method: heartbeat
reminder_interval: 4hAgents now register commitments with the Gateway’s heartbeat service, receiving reminders only when the connection is already active. This efficiently replaces the aggressive polling model from v2026.3.x, which could be resource-intensive. The system supports up to 100 pending commitments per agent with automatic expiration handling, ensuring that old commitments do not clutter the system. You can view pending commitments via claw commitments list --agent-id <uuid>, allowing you to monitor and manage scheduled follow-ups effectively.
Navigating the Marketplace Discovery Interface for Skills
v2026.4.27 introduced a built-in marketplace discovery system for finding and installing skills without manual GitHub searches, streamlining the process of expanding your agent’s capabilities. Access this feature via ./claw marketplace search --category automation or browse categories including computer-use, memory, and channels to find relevant tools. Install skills with verification to ensure their authenticity and integrity:
./claw marketplace install skill/slack-thread-manager --verify-sigThe marketplace now integrates seamlessly with the Codex Computer Use setup flow, suggesting compatible skills during installation, which simplifies the initial configuration. All listed skills undergo OpenGrep scanning and GHSA triage policy checks before publication, ensuring a high level of security and reliability. You can also configure private marketplaces by adding custom registries to your marketplace.yaml file, enabling secure access to proprietary or internal skills:
registries:
- url: https://marketplace.internal.company.com
auth: bearer_tokenThis private marketplace functionality is particularly useful for enterprise environments that require strict control over the skills available to their agents.
Integrating DeepInfra for Model Discovery and Media Generation
DeepInfra joined the bundled providers in v2026.4.27, offering GPU-accelerated inference without requiring local hardware, making advanced AI capabilities more accessible. This integration allows OpenClaw agents to leverage powerful models for various tasks. Configure DeepInfra in your providers.yaml file by adding your API key and specifying the features you wish to enable:
deepinfra:
api_key: ${DEEPINFRA_API_KEY}
model_discovery: true
features:
- text_generation
- image_generation
- tts
- embeddingsReference models using the deepinfra/ prefix, such as deepinfra/meta-llama/Meta-Llama-3-70B-Instruct, to access a wide range of available models. The integration supports streaming Text-to-Speech (TTS) for real-time voice agents and image editing via the edit_image tool, enabling dynamic media workflows. DeepInfra uses provider-owned onboarding policies, meaning authentication flows handle token refresh automatically, simplifying management. For media generation workflows, specify provider: deepinfra in your skill manifest to offload GPU workloads while keeping the Gateway on lightweight CPU instances, optimizing resource utilization.
Upgrading to People-Aware Memory with Provenance Tracking
Memory in v2026.4.29-beta.3 evolved into a people-aware wiki that tracks who said what and when, significantly enhancing accountability and context management. This upgrade is crucial for applications requiring detailed audit trails and personalized interactions. Enable provenance views in your memory.yaml configuration to activate this advanced tracking:
memory:
type: people_aware_wiki
provenance_tracking: true
per_conversation_filters: trueEach memory entry now includes source_conversation_id, participant_ids, and timestamp, creating comprehensive audit trails for compliance and debugging. The provenance view API allows you to query specific information, such as “What did user X tell the agent last Tuesday?”, with full historical context. This replaces the flat key-value store from earlier versions, offering a much richer and more structured memory system. While storage overhead increases by approximately 30% due to the additional metadata, retrieval accuracy improves significantly, especially for multi-user scenarios. Use claw memory inspect --conversation-id <id> to view the provenance chain for any stored fact, providing deep insights into your agent’s knowledge acquisition.
Configuring Per-Conversation Active Memory Filters
Active Memory now supports per-conversation filters, letting you scope recall to specific dialogue contexts rather than relying on a global search. This feature prevents context mixing and improves the relevance of recalled information, especially in multi-user or multi-task environments. Configure these filters in your agent runtime settings to optimize memory recall:
memory:
active_memory:
filter_mode: conversation_scoped
partial_recall_on_timeout: true
timeout_seconds: 30When an agent hits the configured 30-second recall timeout, it returns partial results rather than failing entirely, preventing hangs during complex queries and ensuring a more resilient agent. The bounded REM (Rapid Eye Movement) preview diagnostics show exactly which memory segments loaded for each query, helping you debug why an agent recalled specific facts. This is particularly crucial for customer support agents handling multiple concurrent tickets, where cross-contamination of context can lead to significant confusion and incorrect responses. By isolating memory contexts, agents can maintain focus and provide more accurate, relevant information.
Handling Partial Recall Timeouts and REM Diagnostics
When memory queries exceed configured timeouts, v2026.4.29-beta.3 implements partial recall rather than total failure, enhancing the agent’s resilience and responsiveness. This means that even if a full memory retrieval takes too long, the agent can still provide the most relevant information it managed to gather within the time limit. To monitor and understand this behavior, you can use REM diagnostics:
./claw diagnostics memory --conversation-id <uuid> --show-rem-previewThis command outputs a bounded preview showing which embeddings loaded before the timeout, typically the 50 most relevant chunks. This diagnostic tool is invaluable for debugging and optimizing your memory configuration. You can adjust your timeout thresholds based on these diagnostics in your memory configuration:
memory:
recall:
timeout: 30s
partial_return: true
max_chunks: 50For large knowledge bases exceeding 100,000 documents, consider enabling the new BM25+vector hybrid index introduced in this release. This hybrid index significantly reduces recall latency by 60% for exact-match queries while maintaining robust semantic search capabilities for vague or complex requests, offering a powerful solution for extensive information retrieval needs.
Setting Up NVIDIA and Bedrock Opus 4.7 Providers
v2026.4.29 expands provider coverage with NVIDIA catalog onboarding and Bedrock Opus 4.7 thinking parity, offering more options for high-performance and advanced reasoning models. This broadens the capabilities available to your OpenClaw agents. Configure NVIDIA as a provider by enabling catalog synchronization and specifying manifest-backed authentication paths:
nvidia:
catalog_sync: true
model_auth_path: manifest-backed
api_key: ${NVIDIA_API_KEY}The manifest-backed authentication paths reduce startup time by caching model metadata locally, refreshing only when NVIDIA publishes new catalog versions, ensuring efficient access to the latest models. For Bedrock Opus 4.7, configure the model and enable the thinking parity feature:
bedrock:
model: opus-4.7
thinking_parity: true
region: us-east-1The thinking parity feature exposes the model’s reasoning tokens via the thinking stream, allowing your agents to observe step-by-step logic for debugging complex reasoning tasks. This transparency is invaluable for understanding and improving agent performance. Both providers support the new safer replay and streaming behavior that prevents token leakage between sessions, enhancing security and data integrity.
Securing Tool Profiles: Migrating to Explicit alsoAllow Entries
The v2026.4.29-beta.3 security update removes implicit tool widening, a critical change for maintaining a robust security posture. If you use restrictive profiles like messaging or minimal, you must now explicitly allow tools.exec or tools.fs via alsoAllow. This ensures that permissions are granted deliberately, preventing unintended privilege escalation. To check for affected configurations, run the validation command:
./claw config validate --check-securityIf you see warnings about implicit widening, you must migrate your configuration to explicitly declare these permissions. Here is an example of how to update your security.yaml file:
security:
profile: messaging
alsoAllow:
- tools.exec
- tools.fs
exec:
allowed_commands: ["git", "npm"]Without this explicit declaration, the framework strips exec and fs capabilities even if they are defined elsewhere in your tools section, effectively preventing privilege escalation attacks. The startup warning identifies exactly which configurations need migration, referencing GitHub issue #47487 for additional context and guidance, ensuring a smooth and secure transition.
Optimizing Gateway Startup with Manifest-First Metadata
v2026.4.29 introduces manifest-first metadata to combat slow-host startup issues, significantly improving the responsiveness of your OpenClaw deployments. This optimization is particularly beneficial for large-scale or frequently restarted systems. Configure reusable catalogs in your gateway.yaml file to leverage this feature:
gateway:
startup:
mode: manifest_first
model_catalog_cache: persistent
prewarm_providers: ["openai", "deepinfra"]
event_loop_readiness: strictThe event-loop readiness diagnostic blocks the HTTP server startup until all asynchronous dependencies (such as databases, provider connections, and plugin registries) report as healthy. This eliminates the 500 errors commonly encountered during cold starts, ensuring a more stable and reliable initialization process. Version-scoped update caches prevent redundant plugin downloads during rolling restarts, further accelerating the startup process. For large deployments with 50 or more plugins, this optimization can reduce startup time from approximately 45 seconds to as little as 8 seconds on subsequent restarts, drastically improving operational efficiency.
Troubleshooting Common Deployment Issues
Encountering issues during deployment is common, and OpenClaw v2026.4.29-beta.3 provides several tools and configurations to help. If you experience Slack Block Kit limits, verify your message blocks stay under 50 elements; the framework now auto-splits but logs warnings, so check your logs for these alerts. For Telegram proxy failures, ensure channels.telegram.proxy_failover is enabled and verify the validity of your webhook SSL certificates. Discord rate limits trigger automatic backoff; you can view the current status with claw channels discord --status to understand if you are hitting these limits.
WhatsApp delivery issues often stem from stale sessions; use claw sessions repair --channel whatsapp to force re-authentication and re-establish a stable connection. If you are experiencing IPv6 connectivity issues with web-fetch operations, enable ULA opt-in for trusted proxies in your network.yaml file:
network:
web_fetch:
ipv6_ula_opt_in: trueFor Windows restart handoffs, ensure the claw-service user has “Log on as a service” rights to allow proper system integration. Finally, use claw diagnostics gateway --startup to identify any slow-host bottlenecks during initialization, which can pinpoint performance issues and guide further optimization efforts.
Comparison of OpenClaw Features Across Versions
To illustrate the evolution of OpenClaw, here’s a comparison of key features across recent major versions. This table highlights how the framework has matured, adding significant capabilities and improving existing ones to meet the demands of advanced AI agent deployments.
| Feature Area | OpenClaw v2026.3.x (Legacy) | OpenClaw v2026.4.x (Current Beta) |
|---|---|---|
| Architecture | Centralized RPC model (nodes.run) | Distributed, unified execution model (direct skill invocation), manifest-first metadata |
| Latency (per call) | ~100ms | ~60ms (40ms reduction) |
| Memory System | Flat key-value store, limited context | People-aware wiki, provenance tracking, per-conversation filters, partial recall |
| Security (MCP) | Permissive defaults, implicit tool widening | Fail-closed validation, explicit alsoAllow for tools, sandbox boundary testing |
| Automation | Static configuration, prone to stuck agents | Active-run steering (default), dynamic pivot strategies, context evaluation |
| Channel Adapters | Basic message handling, manual rate-limit management | Visible-reply enforcement, auto Block Kit limits, proxy failover (Telegram), Discord rate-limit backoff |
| Subagent Management | Limited lineage tracking, orphaned subagents | Automatic routing metadata injection, context propagation, ttl |
| Reminders/Commitments | Aggressive polling for follow-ups | Heartbeat-delivered commitments, opt-in system, reduced resource drain |
| Provider Integration | Manual model discovery, fewer bundled providers | Manifest-backed model discovery, DeepInfra/NVIDIA/Bedrock Opus 4.7, thinking parity |
| Startup Optimization | Slow host startup, race conditions | Manifest-first metadata, event-loop readiness, persistent model catalog cache |
| Marketplace | Manual plugin installation via GitHub | Built-in marketplace discovery, verify-sig for installation, private registries |
| Diagnostics | Basic logging | Comprehensive diagnostics (memory, gateway startup, channels), REM preview, ULA opt-in |
This comparison demonstrates a clear progression towards a more robust, secure, efficient, and user-friendly framework, addressing many of the limitations present in earlier versions and positioning OpenClaw as a leading solution for self-hosted AI agents.
Frequently Asked Questions
What is OpenClaw and how does it differ from managed AI agent services?
OpenClaw is an open-source AI agent framework that runs entirely on your local infrastructure or self-hosted servers, giving you complete control over data, models, and execution environments. Unlike managed services such as AutoGPT Cloud or commercial orchestrators, OpenClaw processes all agent reasoning, memory, and tool execution locally by default, with optional gateway federation for distributed workloads. The framework supports over 347,000 GitHub stars worth of community contributions and integrates with providers like DeepInfra, NVIDIA, and Bedrock while maintaining a zero-trust security model with fail-closed MCP checks.
How do I configure Codex Computer Use with fail-closed MCP validation?
Install the Codex Computer Use plugin using the new status and install commands introduced in v2026.4.27. Configure fail-closed MCP checks in your gateway config by setting mcp.validation.mode: 'fail-closed' to ensure any Model Context Protocol tool that fails authentication or schema validation immediately halts execution rather than falling back to permissive defaults. This prevents unauthorized desktop control when running Codex-mode agents with computer-use capabilities.
What are the breaking changes in tool security profiles for v2026.4.29?
Starting with v2026.4.29-beta.3, configured tool sections including tools.exec and tools.fs no longer implicitly widen restrictive profiles like messaging or minimal. Previously, having these tools in your config automatically elevated permissions; now you must explicitly add alsoAllow entries to grant capabilities under restricted profiles. The framework emits a startup warning identifying affected configurations, forcing explicit security declarations rather than implicit privilege escalation.
How does DeepInfra integration work for media generation and TTS?
DeepInfra joined the bundled provider set in v2026.4.27, offering native model discovery, media generation, editing capabilities, text-to-speech, and embeddings through provider-owned onboarding policies. Configure DeepInfra in your providers.yaml with your API key, then reference models using the deepinfra/ prefix. The integration uses manifest-backed model paths for faster authentication and supports streaming responses for real-time TTS and image generation workflows.
What is active-run steering and when should I enable it?
Active-run steering, now enabled by default in v2026.4.29-beta.3, allows you to dynamically adjust agent behavior during automation runs without restarting the process. When enabled, the agent monitors execution context and can pivot strategies based on intermediate results. You should enable this for long-running messaging automations, multi-step data pipelines, and subagent orchestration where static configuration proves too rigid for variable real-world conditions.