OpenClaw is an open-source AI agent framework that transforms large language models into autonomous, stateful applications capable of executing complex workflows without human intervention. Unlike simple chatbot wrappers, OpenClaw implements a graph-based execution engine where agents traverse nodes, maintain persistent memory, and invoke tools through a type-safe skill system. Built in TypeScript but language-agnostic through its gRPC interface, it runs entirely on your hardware, keeping API keys and sensitive data local. As of April 2026, the framework powers everything from automated trading systems to content pipelines, with 347,000 GitHub stars making it the most starred project in the ecosystem. You write YAML configurations and Python skills, the engine handles orchestration.
What You Will Accomplish: Building a Production-Ready Research Agent
By the end of this guide, you will have deployed an autonomous research agent that accepts natural language queries, searches the web via API integration, synthesizes findings into structured markdown documents, and stores results in a local SQLite database with full revision history. This agent handles rate limiting gracefully, retries failed API calls with exponential backoff, and maintains conversation context across sessions using persistent memory. You will understand OpenClaw’s three-layer architecture: the runtime executes nodes in a directed graph, the skill registry manages type-safe capabilities written in Python, and the memory layer persists state across restarts. The final artifact runs in a hardened Docker container, exposes a REST API for integration with frontend applications, and includes Prometheus metrics hooks for production monitoring. This implementation handles real concurrency, processes multiple research topics simultaneously, and costs approximately $0.12 per 100 queries when using Claude 3.5 Sonnet. These patterns scale directly to hundreds of concurrent agents handling production business workflows without modification.
Prerequisites: Hardware, Software, and API Keys
You need a machine with 8GB RAM minimum, 16GB recommended for concurrent agents or local LLM inference. OpenClaw supports macOS 14+, Ubuntu 22.04+, and Windows 11 with WSL2. Install Node.js 20+, Python 3.11+, and Docker Desktop 4.25 or later. You will need API keys from at least one provider: OpenAI, Anthropic, or a local endpoint via Ollama. For the web search capability demonstrated in this guide, obtain a Tavily or Serper API key. Clone the repository with git and ensure port 3000 is free for the web dashboard. If you plan to use persistent storage beyond SQLite, install PostgreSQL 15 locally or have a Docker volume ready with 10GB free space. The CLI requires sudo privileges for initial installation on Linux systems to create the global binary symlink. Verify your Python installation includes pip and virtualenv support.
Step 1: Installing OpenClaw via CLI and Docker
Open your terminal and run the installation command: curl -fsSL https://install.openclaw.dev | bash. This installs the claw CLI globally to /usr/local/bin. Verify with claw --version, expecting v2026.4.27 or later. Initialize a new project with claw init research-agent, which scaffolds a directory with config/, skills/, and data/ folders. For containerized deployment, pull the official image: docker pull openclaw/core:latest. Create a docker-compose.yml mounting your project directory as a volume with read-only permissions where appropriate. The CLI automatically detects your shell and adds completion scripts for bash, zsh, or fish. First run downloads the 400MB core binary. If you prefer building from source, clone the GitHub repo and run pnpm install followed by pnpm build. The build process compiles the TypeScript runtime and Python bindings, taking approximately 5 minutes on a modern laptop.
curl -fsSL https://install.openclaw.dev | bash
claw --version
claw init research-agent
docker pull openclaw/core:latestStep 2: Understanding Nodes, Edges, and the Execution Graph
OpenClaw models agents as directed graphs where nodes represent discrete computation units and edges define transition logic. A node can be an LLM call, a Python function, or a conditional branch that evaluates context variables. Edges carry state between nodes as immutable context objects, preventing side effects from poisoning downstream execution. When you define an agent, you create a .claw file containing node definitions and edge mappings using JSONPath expressions or JavaScript predicates for conditional routing. Unlike linear pipelines, OpenClaw supports cycles for iterative refinement loops, allowing agents to repeat steps until quality thresholds meet. Each node execution produces a trace entry you can inspect later through the web UI or CLI. Understanding this graph model is crucial because it determines how your agent handles failures, retries, and parallel execution paths. The execution engine evaluates the graph lazily, only materializing nodes when their dependencies resolve.
The graph structure ensures deterministic execution, which is vital for debugging and auditing agent behavior. By explicitly defining the flow, developers can predict how an agent will respond to various inputs and prevent unexpected LLM hallucinations from derailing complex tasks. This contrasts with more dynamic approaches where the LLM dictates the next step, which can lead to non-deterministic and hard-to-debug behaviors. OpenClaw’s graph-based approach provides a robust foundation for building reliable and auditable AI agents for critical business processes.
Step 3: Configuring Your First Agent YAML
Create agent.yaml in your project root. Define the agent metadata: name: research-agent, version: 1.0.0, and a description. Specify the default model under providers, referencing your API keys from environment variables using the ${ANTHROPIC_API_KEY} syntax. The nodes section lists your execution steps. Start with a trigger node that accepts HTTP POST requests on port 3000, followed by an llm node using the claude-3-5-sonnet-20250219 model. Configure the memory block to use sqlite:///data/memory.db with a TTL of 3600 seconds for automatic expiration. Set max_iterations: 10 to prevent infinite loops during development. The skills array references Python modules in your skills/ directory. Validate the configuration with claw validate agent.yaml. The CLI checks for syntax errors, missing environment variables, and circular dependencies in your graph before allowing execution. Save the file; the runtime watches for changes and hot-reloads valid configurations.
# agent.yaml
name: research-agent
version: 1.0.0
description: "An autonomous agent for web research and document synthesis."
providers:
- id: anthropic
type: anthropic
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-5-sonnet-20250219
rate_limits:
requests_per_minute: 50
tokens_per_minute: 40000
- id: openai
type: openai
api_key: ${OPENAI_API_KEY}
model: gpt-4o-2025-04-15
rate_limits:
requests_per_minute: 60
tokens_per_minute: 60000
memory:
adapter: sqlite
connection_string: sqlite:///data/agent.db
ttl: 3600 # 1 hour
summarization_threshold: 0.8 # Summarize if context usage exceeds 80%
nodes:
- id: start_research
type: trigger
endpoint: /research
method: POST
description: "Initiates a new research task."
output_schema:
type: object
properties:
query: { type: string, description: "The research query." }
- id: initial_llm_analysis
type: llm
provider: anthropic
prompt: |
You are a world-class research assistant. Given the query: {{ input.query }},
break it down into key search terms and identify potential sub-topics.
Output a JSON array of strings, where each string is a search term.
output_key: search_terms
max_iterations: 10 # Prevent infinite loops
next: execute_web_search
skills:
- module: skills.web_search
# Other skills will be added hereStep 4: Writing a Custom Skill in Python
Skills extend OpenClaw’s capabilities beyond built-in LLM calls. Create skills/web_search.py implementing the skill decorator pattern. Import requests and define a function annotated with @skill(name="web_search", description="Searches the web"). Accept parameters query (string) and top_n (integer) with type hints. Implement the search logic using your Tavily API, returning a structured JSON object with sources and summaries. OpenClaw injects a context object containing conversation history and ephemeral state. Handle errors gracefully by raising SkillException with retry=True to trigger automatic backoff. Save the file and register it in agent.yaml under the skills section with the module path skills.web_search. The framework hot-reloads Python modules during development, so changes reflect immediately without restarting the runtime. Complex skills can import external libraries listed in requirements.txt at the project root.
# skills/web_search.py
import os
import requests
from openclaw.skills import skill, SkillException
@skill(name="web_search", description="Searches the web for given query.")
def web_search(context, query: str, top_n: int = 5) -> dict:
"""
Performs a web search using the Tavily API and returns structured results.
"""
tavily_api_key = os.getenv("TAVILY_API_KEY")
if not tavily_api_key:
raise SkillException("TAVILY_API_KEY environment variable not set.", retry=False)
url = "https://api.tavily.com/search"
headers = {
"Content-Type": "application/json"
}
data = {
"api_key": tavily_api_key,
"query": query,
"search_depth": "advanced",
"include_answer": True,
"include_raw_content": False,
"max_results": top_n
}
try:
response = requests.post(url, headers=headers, json=data, timeout=30)
response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
results = response.json()
return {
"query": query,
"answer": results.get("answer"),
"results": [
{"title": r.get("title"), "url": r.get("url"), "content": r.get("content")}
for r in results.get("results", [])
]
}
except requests.exceptions.RequestException as e:
context.log.error(f"Web search failed for query '{query}': {e}")
raise SkillException(f"Web search API error: {e}", retry=True)Step 5: Connecting to Anthropic Claude and OpenAI GPT-4o
OpenClaw abstracts model providers through a unified interface supporting OpenAI-compatible endpoints. In your provider configuration, define multiple endpoints for redundancy and failover. For Anthropic, set base_url: https://api.anthropic.com/v1 and model: claude-3-5-sonnet-20241022. For OpenAI, use gpt-4o-2025-04-15 with your API key. Enable automatic failover by listing providers in priority order; if the first returns a 5xx error or rate limit, OpenClaw switches to the second within 500ms. Set rate limiting parameters: requests_per_minute: 50 and tokens_per_minute: 40000 to avoid throttling. For local development with Ollama, point to http://localhost:11434/v1 with model llama3.3:70b. The framework handles authentication headers, request formatting, and response parsing automatically. You can override the default model per-node using the model_override parameter in specific node configurations for cost optimization on simpler tasks.
This intelligent provider switching mechanism is critical for maintaining agent uptime and cost efficiency in production. By defining multiple providers with sensible rate limits and priority, your agents can continue operating even if one API endpoint experiences an outage or temporary throttling. This multi-provider strategy also allows for A/B testing of different models and dynamic routing of requests based on cost, latency, or specific task requirements. OpenClaw’s flexibility in model integration ensures that your agents can leverage the best available LLM for any given task without extensive code changes.
Step 6: Implementing Persistent Memory with SQLite
Stateless agents forget everything between runs, limiting their utility. Configure persistent memory by adding a memory block to your agent.yaml. Use the SQLite adapter for lightweight deployments: adapter: sqlite, connection_string: sqlite:///data/agent.db. For production workloads, switch to PostgreSQL with connection pooling enabled. Memory entries store as JSON blobs with timestamps and TTL values, automatically indexed for fast retrieval. Access memory in skills via context.memory.get(key) and context.memory.set(key, value, ttl=3600). The framework automatically prunes expired entries every 5 minutes to prevent database bloat. Enable memory summarization for long conversations, which compresses history using the LLM when token counts exceed 80% of the context window. This prevents context window exhaustion and reduces API costs by 40% on average for multi-turn interactions while maintaining conversation coherence.
Beyond basic key-value storage, OpenClaw’s memory system supports advanced features like semantic search over past interactions, allowing agents to recall relevant information even if the exact keywords are not present in the current prompt. This is achieved by optionally integrating with vector databases like Chroma or Weaviate, which can be configured as an additional memory adapter. The memory block also supports different eviction policies, such as Least Recently Used (LRU) or Least Frequently Used (LFU), giving developers fine-grained control over how memory is managed and optimized for specific agent behaviors.
Step 7: Adding Tool Use for Web Search and Calculations
Tools differ from skills in that they execute immediately within the LLM generation loop without graph traversal. Define tools in your configuration under the tools section. Add the built-in calculator tool for mathematical operations using Python’s eval in a sandboxed environment. For web search, reference your custom skill from Step 4 as a tool by exporting a JSON Schema definition. The LLM receives function definitions in OpenAI’s tool format and decides when to invoke them based on user prompts. When the model calls a tool, OpenClaw pauses the LLM node, executes the tool with the provided arguments, and injects the stringified result back into the context before continuing generation. This happens transparently within the token budget. Set parallel_tool_calls: true to allow multiple tool invocations in a single generation pass, reducing latency for complex research tasks requiring both calculation and search.
The distinction between skills and tools is crucial for understanding OpenClaw’s design philosophy. Skills are foundational, offering programmatic control over complex logic and external integrations. Tools, on the other hand, are the LLM’s interface to these capabilities, enabling the model to “think” by calling external functions to gather information or perform actions. This separation allows developers to build robust, testable skills independently, then expose them as tools to the LLM with clear JSON Schema contracts, ensuring reliable interaction and preventing malformed arguments.
Step 8: Orchestrating Multi-Agent Workflows
Single agents hit complexity limits on tasks requiring diverse expertise. OpenClaw supports multi-agent orchestration through the delegate node type. Create a supervisor agent that breaks tasks into subtasks, then spawns worker agents via delegate nodes with specific system prompts. Each worker operates in its own memory context but reports back to the supervisor through message passing. Configure patterns: fan-out for parallel processing of independent subtasks, pipeline for sequential dependencies where output feeds into input, or reduce for aggregation of multiple results. Set resource limits per sub-agent to prevent runaway token consumption, specifying max_tokens: 2000 per delegation. The orchestration graph visualizes in the web UI, showing real-time execution flow, bottlenecks, and token consumption per agent. Use this pattern to build research teams where one agent searches, another fact-checks against knowledge bases, and a third writes the final summary document.
Multi-agent coordination in OpenClaw is not just about distributing tasks but also about managing communication and conflict resolution. The framework provides mechanisms for agents to share information, negotiate tasks, and even perform peer reviews on each other’s outputs. This allows for the creation of sophisticated, autonomous systems that mimic human team dynamics, leading to higher quality and more reliable outcomes for complex projects. The delegate node can also be configured with retry policies and fallback agents, ensuring that critical subtasks are completed even if a primary worker agent encounters an unrecoverable error.
Step 9: Securing Your Agent with Environment Isolation
Running AI agents with API keys and file system access creates significant security risks if compromised. OpenClaw implements defense in depth through containerized execution. Enable the security module in config.yaml with sandbox: docker. This runs skills in ephemeral containers with read-only filesystems, no network access except whitelisted domains, and CPU/memory limits. Secrets inject via environment variables never logged to disk or appearing in stack traces. Use the secrets manager to rotate API keys automatically every 24 hours. Enable audit logging to track every tool invocation and LLM call with full request/response payloads stored to append-only logs. For sensitive deployments, integrate with ClawShield or AgentWard for additional runtime enforcement and anomaly detection. The framework supports mTLS for inter-agent communication in multi-agent setups, preventing man-in-the-middle attacks on internal message buses between delegated workers.
Beyond Docker sandboxing, OpenClaw also supports kernel-level isolation technologies like gVisor or Kata Containers for maximum security in multi-tenant environments. The granular control over network access, CPU, and memory resources means that even if a skill or tool is exploited, the blast radius is severely limited, protecting your core infrastructure and sensitive data. The audit logging features are compliant with major regulatory standards, providing a comprehensive record of all agent activities for compliance and forensic analysis. This commitment to security makes OpenClaw suitable for enterprise applications where data privacy and system integrity are paramount.
Step 10: Deploying to Production with Docker Compose
Production deployments require reliability, persistence, and horizontal scaling capability. Create a docker-compose.yml defining three services: the OpenClaw runtime with your project mounted, a PostgreSQL 15 database for memory persistence, and a Redis 7 instance for message queuing between agents. Mount your project directory as read-only to prevent runtime mutations. Set restart policies to unless-stopped with health checks on the /healthz endpoint returning HTTP 200. Expose port 3000 for the REST API and 8080 for the web dashboard. Configure health checks with 30-second intervals. Use Docker secrets or a .env file for API keys, never committing them to version control. The official image includes nginx for static file serving and Prometheus exporters for metrics scraping. Scale horizontally by increasing replica counts and using the shared PostgreSQL backend for state consistency across instances.
# docker-compose.yml
version: '3.8'
services:
openclaw:
image: openclaw/core:latest
container_name: openclaw_runtime
ports:
- "3000:3000" # Agent REST API
- "8080:8080" # Web Dashboard
volumes:
- ./config:/app/config:ro # Mount agent configurations as read-only
- ./skills:/app/skills:ro # Mount Python skills as read-only
- ./data:/app/data # Persistent data for SQLite, logs, etc.
environment:
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
- OPENAI_API_KEY=${OPENAI_API_KEY}
- TAVILY_API_KEY=${TAVILY_API_KEY}
- LOG_LEVEL=info
- DATABASE_URL=postgresql://user:password@postgres:5432/openclaw_db
- REDIS_URL=redis://redis:6379/0
depends_on:
- postgres
- redis
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000/healthz"]
interval: 30s
timeout: 10s
retries: 5
postgres:
image: postgres:15
container_name: openclaw_postgres
environment:
- POSTGRES_DB=openclaw_db
- POSTGRES_USER=user
- POSTGRES_PASSWORD=password
volumes:
- postgres_data:/var/lib/postgresql/data
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U user -d openclaw_db"]
interval: 10s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
container_name: openclaw_redis
volumes:
- redis_data:/data
restart: unless-stopped
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 5
volumes:
postgres_data:
redis_data:Step 11: Performance Tuning for High-Throughput Workloads
Default settings optimize for correctness and debuggability, not raw throughput. Tune your deployment by enabling response caching for deterministic tool calls. Set cache_ttl: 300 seconds for web searches that return similar results. Configure connection pooling for your database connections, limiting to 20 concurrent connections per instance to prevent exhaustion. Use the async skill executor for I/O bound operations like HTTP requests by decorating with @skill(async=True). Enable request batching for LLM calls when processing multiple similar prompts simultaneously. Monitor token usage with the built-in dashboard and set hard limits per agent using max_cost_usd: 5.00 to prevent cost overruns. For CPU-bound Python skills, use multiprocessing pools instead of threading to bypass the GIL. Profile execution with claw profile --output flamegraph.html to identify slow nodes in your graph.
Further optimization can be achieved by employing techniques like prompt compression or distillation, where larger, more capable LLMs are used to generate concise, high-quality prompts for smaller, faster models. This “teacher-student” approach can significantly reduce inference costs without sacrificing much quality. Implementing custom caching layers for frequently accessed external data, such as knowledge bases or API responses, can also minimize redundant calls and improve overall latency. OpenClaw’s modular architecture allows for the integration of these advanced performance techniques without altering the core framework logic.
Step 12: Testing Your Agents: Unit Tests and Integration Patterns
Untested agents fail silently in production, often expensively. OpenClaw provides a testing framework via claw test. Write YAML test cases in tests/ defining input prompts and expected output patterns using regex or JSON Schema validation. Mock external APIs by defining fixtures in tests/fixtures/ that return canned responses without hitting real services. Run unit tests for individual skills using pytest with the openclaw-testing package, which provides mocks for context and memory. For integration tests, spin up ephemeral agent instances using the TestRuntime class in Python. Test error handling by injecting faults into tool calls to verify retry logic. Set up CI/CD pipelines to validate agent configurations on every commit using claw validate. The framework includes property-based testing helpers that generate random inputs to check for edge cases in your logic and prevent prompt injection vulnerabilities.
# tests/research_agent_test.yaml
name: "Research Agent Basic Functionality"
description: "Tests the research agent's ability to process a query and perform a web search."
agent_path: agent.yaml
test_cases:
- name: "Simple web search query"
input:
trigger_node_id: start_research
payload:
query: "What is the capital of France?"
expected_output:
- node_id: initial_llm_analysis
output_key: search_terms
pattern: '["capital of France", "Paris"]' # Regex or JSONPath validation
- name: "Query with multiple sub-topics"
input:
trigger_node_id: start_research
payload:
query: "Latest advancements in AI and their impact on society."
expected_output:
- node_id: initial_llm_analysis
output_key: search_terms
pattern: 'ai advancements|impact on society' # Using regex to match contentStep 13: Troubleshooting: Logs, Debug Mode, and Common Failures
When agents behave unexpectedly, start with claw logs --follow to tail real-time execution across all nodes. Enable debug mode by setting LOG_LEVEL=debug in your environment. This traces every node transition, memory access, and tool invocation with full JSON payloads in the logs. Common failure modes include rate limiting (HTTP 429), context window exceeded (token overflow errors), and infinite loops (max_iterations exceeded). Fix rate limits by implementing exponential backoff in your provider configuration. Resolve token overflow by enabling memory summarization or truncating history manually in skills. For stuck agents, use claw debug --attach <agent-id> to inspect live state and pause execution. Check the web dashboard’s execution graph visualization to identify which node failed with red highlighting. The community Discord maintains a searchable database of edge cases and solutions for provider-specific quirks.
Beyond these common issues, developers should also be aware of potential model biases or unexpected behaviors, which can sometimes manifest as subtle errors in agent output. OpenClaw’s detailed logging and tracing capabilities are invaluable for identifying these subtle issues, allowing for prompt engineering adjustments or skill refinements. The framework also supports integration with alert systems, so you can be notified immediately if an agent enters a failed state or exceeds predefined error thresholds, enabling proactive maintenance and minimizing downtime.
Step 14: Integrating OpenClaw with Existing Microservices
Agents rarely operate in isolation within enterprise environments. Expose your OpenClaw agent via REST API using the built-in HTTP trigger node, which accepts JSON POST requests and returns structured responses. Configure webhook endpoints to receive callbacks from external services like GitHub, Stripe, or internal CRM systems. Use the messaging adapter to connect to RabbitMQ or Kafka for event-driven architectures, consuming events as trigger inputs. Import existing Python libraries by adding them to requirements.txt in your project root; the runtime installs dependencies in isolated virtual environments on startup. For legacy systems without APIs, use the exec node to shell out to existing CLI tools, capturing stdout and stderr into the context for LLM processing. The framework supports OpenTelemetry for distributed tracing, allowing you to correlate agent actions with requests in your existing observability stack like Datadog or Grafana.
The extensibility of OpenClaw through its various adapters and node types means it can act as a central orchestration layer for diverse enterprise systems. Whether you need to automate a customer support workflow that interacts with a CRM and a knowledge base, or a financial analysis agent that pulls data from multiple market APIs, OpenClaw provides the glue. Its gRPC interface further enables integration with services written in other languages, ensuring that OpenClaw agents can seamlessly become part of a polyglot microservices ecosystem. This makes it an ideal choice for organizations looking to integrate AI capabilities into their existing infrastructure without extensive refactoring.
Step 15: Migrating from AutoGPT: Architecture Comparison
Teams switching from AutoGPT need to understand fundamental architectural differences before porting workflows. OpenClaw uses static YAML configurations defining explicit execution graphs, while AutoGPT relies on dynamic goal interpretation by the LLM. This provides predictability and reproducibility but requires upfront design of your control flow. AutoGPT runs as a monolithic Python process; OpenClaw distributes across containerized nodes with clear separation of concerns. Memory in AutoGPT uses vector databases by default for semantic recall; OpenClaw prefers structured SQLite or PostgreSQL with optional vector extensions for exact recall with semantic fallback. Tool definition in AutoGPT relies on prompt engineering; OpenClaw uses strict JSON Schema validation. The following table summarizes key differences:
| Feature | AutoGPT | OpenClaw |
|---|---|---|
| Configuration | Dynamic goals (LLM-driven) | Static YAML graphs |
| Execution Model | Single process, sequential | Distributed nodes, parallel |
| Memory Storage | Pinecone/Chroma (Vector DB) | SQLite/PostgreSQL (Relational), optional vector |
| Primary Language | Python | TypeScript runtime, Polyglot skills (Python, JS) |
| Observability | Basic console logging, some plugins | Structured traces, Web UI, Prometheus metrics |
| Sandboxing | Limited (Python exec risks) | Docker containers, gVisor support |
| Tool Definition | Prompt engineering, less strict | Strict JSON Schema |
| Scalability | Vertical scaling (single instance) | Horizontal scaling (distributed cluster) |
| Determinism | Low, LLM can change behavior | High, explicit graph control |
| Error Handling | Basic retries, often manual intervention | Configurable retries, fallback nodes, circuit breakers |
Migration involves translating AutoGPT plugins into OpenClaw skills and replacing goal-based prompts with explicit node graphs, typically reducing token costs by 60% while improving reliability. The shift from dynamic LLM-driven execution to a structured graph-based approach means developers have greater control over agent behavior, making OpenClaw a more suitable choice for production environments where reliability, auditability, and cost-efficiency are critical. This architectural paradigm also lends itself better to formal testing and validation, ensuring that agents perform as expected under various conditions.
Frequently Asked Questions
What hardware do I need to run OpenClaw locally?
You need 8GB RAM minimum, 16GB recommended for concurrent agents. OpenClaw runs on macOS 14+, Ubuntu 22.04+, and Windows 11 with WSL2. For local LLM inference without API costs, use a machine with 32GB RAM and an M-series Mac or CUDA-compatible GPU. Storage requirements start at 2GB for the core framework, but allocate 10GB for Docker images, model caches, and persistent databases. ARM64 and x86_64 architectures are fully supported. If running multiple agents simultaneously, scale RAM linearly with agent count, budgeting approximately 500MB per active agent for context windows and memory overhead. For optimal performance with local LLMs, a dedicated GPU with at least 12GB VRAM is highly recommended to handle larger models and context windows more efficiently.
How does OpenClaw differ from LangChain or AutoGPT?
OpenClaw uses static YAML configurations defining explicit execution graphs, while AutoGPT relies on dynamic goal interpretation. LangChain is a library requiring you to build orchestration logic; OpenClaw is a complete runtime with built-in persistence, multi-agent orchestration, and observability. OpenClaw runs as a distributed system with containerized sandboxing, whereas AutoGPT typically runs as a monolithic Python process without isolation. LangChain requires you to manage memory and tool chaining manually; OpenClaw provides these as first-class primitives. For production deployments, OpenClaw offers horizontal scaling, enterprise security features, and a comprehensive web-based dashboard out of the box, while LangChain and AutoGPT require you to build these infrastructure layers yourself, often leading to higher development and maintenance overhead.
Can I use local LLMs like Ollama with OpenClaw?
Yes. Configure the provider section in agent.yaml to point to your Ollama instance at http://localhost:11434/v1. OpenClaw supports any OpenAI-compatible endpoint, including llama.cpp, Ollama, and vLLM. Local models work best with smaller agent graphs and shorter context windows. You lose some advanced features like parallel function calling and sophisticated tool use with smaller models under 70B parameters, but basic node execution and memory persistence function identically to cloud providers. For best results, use quantized GGUF models with 4-bit precision to fit larger contexts in available VRAM. The framework automatically detects model capabilities and disables unsupported features when using local endpoints, ensuring a smooth experience even with less capable models.
How do I secure API keys when deploying OpenClaw agents?
Never commit API keys directly to your code repositories. Use Docker secrets or environment variables injected at runtime through your container orchestration platform (e.g., Kubernetes, Docker Swarm). Enable the security module in your config.yaml with sandbox: docker to run skills in isolated containers with no direct filesystem access to the host and restricted network egress (only to whitelisted domains). Utilize the built-in secrets rotation feature for automatic key cycling, enhancing security posture. For high-security production environments, integrate OpenClaw with external secrets management services like HashiCorp Vault or AWS Secrets Manager via the external secrets provider plugin. Audit logs capture every API call without storing the actual key values, only recording cryptographically secure hashes for correlation and compliance purposes. Rotate keys immediately if you suspect compromise; the framework supports hot reloading of secrets without restarting agents.
What is the difference between Skills and Tools in OpenClaw?
Skills are Python functions you write that execute within the OpenClaw runtime, accessing the agent’s memory and context. They handle complex, multi-step logic, database queries, or interactions with external APIs, and can run for extended periods. Skills are invoked directly by nodes in the execution graph. Tools, on the other hand, are capabilities exposed to the LLM via strict JSON Schema definitions, allowing the model to decide when and how to invoke them during its text generation process. A skill might implement the entire process of fetching and analyzing weather data for a specific location, while a tool would be the specific function the LLM calls to request that weather data with parameters like city and date. Skills run as part of the graph’s control flow, while tools interrupt the LLM node for immediate execution, returning their results directly into the LLM’s context for further reasoning. Think of skills as the backend services an agent can perform, and tools as the specific functions the AI can call to trigger those services.