Category: Configuration & Tuning

Configure, tune, and customize OpenClaw — memory files, API keys, gateway, and settings.

  • How to Write Better Agent Prompts for OpenClaw (SOUL.md Deep Dive)

    Last Tuesday, a user reported that their OpenClaw agent was repeatedly requesting human approval to execute even routine database queries—a task it was supposed to handle independently. The root cause wasn’t a bug in OpenClaw itself, but a vague SOUL.md file that failed to establish clear operational boundaries. This scenario plays out constantly: agents drift from their intended purpose, hallucinate plausible-sounding but incorrect answers, or get stuck in approval loops. The culprit is almost always an insufficiently detailed SOUL.md. Understanding and leveraging this file—treating it as your agent’s constitutional document rather than a generic instruction set—is the difference between an agent that works reliably and one that constantly needs human intervention.

    Understanding SOUL.md’s Role

    The SOUL.md file isn’t just a README for your agent; it’s the foundational prompt that informs the Language Model (LLM) about its very essence. OpenClaw feeds this file to the LLM during agent initialization, often as part of the system prompt or an initial user message, depending on the LLM provider and OpenClaw’s internal configuration for that provider. It sets the tone, defines the persona, and most importantly, establishes the boundaries of the agent’s operation. Anything not explicitly permitted or constrained here can be open to interpretation by the LLM, which often leads to undesirable outcomes.

    Consider a concrete example: you want an agent to summarize meeting transcripts. A naive SOUL.md might simply say, “You are a meeting summarizer.” This is insufficient. The LLM might then summarize in bullet points, paragraphs, or even a poetic form, depending on its internal biases or training data. A better SOUL.md would provide explicit instructions: “You are a professional meeting summarizer. Your goal is to extract key decisions, action items, and outstanding questions from meeting transcripts. Summaries should be concise, no longer than 300 words, and formatted as a numbered list of decisions, followed by a bulleted list of action items, and finally a bulleted list of questions. If a transcript is unclear or contradictory, flag the specific sections for human review rather than guessing.”

    Deconstructing a SOUL.md File

    A robust SOUL.md typically has several key sections, even if not explicitly labeled with Markdown headers within the file itself. I’ve found it useful to structure them mentally as follows:

    1. Identity/Persona: Who is the agent? What is its role? “You are a Senior DevOps Engineer with ten years of experience managing production infrastructure across AWS, Azure, and on-premises data centers.”
    2. Mission/Goal: What is the agent trying to achieve? “Your primary goal is to identify and resolve performance bottlenecks in Linux server environments, reducing latency and improving resource utilization.”
    3. Constraints/Guardrails: What can’t the agent do? What are its limitations? “You must only use open-source tools like Prometheus, Grafana, and perf. Do not make permanent system changes without explicit human approval via ticket review. Prioritize system stability above all else. Never execute commands as root unless absolutely necessary and pre-approved. Log all diagnostic steps for audit purposes.”
    4. Output Format (if applicable): How should the agent present results? “Provide findings in a structured report: (1) Problem Summary, (2) Diagnostics Performed, (3) Root Cause Analysis, (4) Recommended Actions ranked by impact, (5) Risk Assessment for each recommendation.”
    5. Knowledge Scope: What does the agent know and not know? “You have access to system logs from the past 30 days. You do not have access to application-level metrics; escalate to the application team if needed. You understand Linux internals and networking but are not an expert in database optimization; refer database issues to the DBA team.”
    6. Decision Authority: When can the agent act independently vs. when must it ask? “You may restart non-critical services. You may adjust non-production configurations. You must request approval before modifying production firewall rules or scaling infrastructure.”

    Building a Specific SOUL.md

    Let’s walk through building a SOUL.md for a practical example: a customer support escalation agent. This agent reviews support tickets, determines priority, and routes them to the right team.

    Weak SOUL.md:

    You are a support agent. Triage tickets and route them appropriately.
    

    Strong SOUL.md:

    # Support Escalation Agent
    
    ## Identity
    You are a Level 2 Support Escalation Specialist. Your role is to review unassigned support tickets, assess their urgency and category, and route them to the appropriate team with clear context.
    
    ## Mission
    Your goal is to reduce time-to-resolution by ensuring tickets reach the right team on the first attempt, and to flag critical issues for immediate escalation to management.
    
    ## Ticket Categories and Routing Rules
    - **Billing Issues**: Route to Finance Team. Escalate immediately if customer is threatening to cancel or if overcharge exceeds $500.
    - **Technical Issues - Product A**: Route to Product A Engineering. Add "urgent" tag if customer is on Enterprise plan.
    - **Technical Issues - Product B**: Route to Product B Engineering. Check our internal status page first; if there's a known outage, add context to the ticket.
    - **Feature Requests**: Route to Product Management. Do not escalate unless 5+ customers have requested the same feature (check our request database first).
    
    ## Priority Scoring
    Mark as CRITICAL if: (1) customer is Enterprise-tier AND unable to use product, (2) security issue is mentioned, or (3) customer explicitly states business impact (e.g., "our production is down").
    Mark as HIGH if: (1) customer is on Pro plan AND experiencing issues, or (2) ticket mentions financial loss or reputation risk.
    Mark as NORMAL for all other cases.
    
    ## Constraints
    - Do not promise timelines. Instead, reference our published SLA: "Enterprise issues resolved within 4 hours, Pro within 24 hours."
    - Do not disclose which team is handling the issue if customer has not been informed yet.
    - If a ticket mentions a competitor or industry trend, flag for Product Manager review (add "market-research" tag).
    - Do not close tickets without explicit customer confirmation; instead, mark as "awaiting-customer-response" with a 7-day auto-close timer.
    
    ## Output Format
    For each ticket, provide:
    1. **Recommended Route**: [Team Name]
    2. **Priority**: CRITICAL / HIGH / NORMAL
    3. **Reasoning**: One sentence explaining your routing decision.
    4. **Additional Context**: Any background the receiving team should know.
    5. **Immediate Action Required**: Yes/No, and if yes, describe what.
    
    ## Knowledge Scope
    You have access to: (1) customer account information from the past 12 months, (2) our internal knowledge base, (3) our product status page, (4) the feature request database.
    You do NOT have: (1) real-time product metrics, (2) engineering team availability, (3) sales notes or renewal dates. Escalate tickets referencing these to the Account Management team.
    

    The difference is stark. The strong version provides decision trees, thresholds, and explicit guardrails. An LLM working from the strong version will consistently triage tickets correctly. An LLM working from the weak version will likely invent routing logic, miss escalation opportunities, or make promises it can’t keep.

    Common SOUL.md Mistakes

    Mistake 1: Vague Authority Boundaries
    Weak: “Make reasonable decisions about customer refunds.”
    Strong: “Approve refunds up to $100 without approval. For $100–$500, flag for supervisor review. Above $500, escalate to Finance Director. Never approve refunds for customers with 3+ previous chargebacks.”

    Mistake 2: Missing Edge Cases
    Your SOUL.md should anticipate the weird scenarios. If your agent is a scheduler, what happens when two requests conflict? What if a request comes in at 2 AM on a Sunday? Don’t assume the LLM will handle these gracefully—spell them out.

    Mistake 3: Insufficient Output Examples
    Don’t just say “provide a summary.” Show an example. If your agent should output JSON, show the schema. If it should output prose, show a paragraph-length example with the tone and detail level you expect.

    Mistake 4: Not Defining Escalation Paths
    Every agent should have a clear answer to: “What do I do when I’m stuck?” Provide explicit escalation triggers. “If the issue doesn’t fit any known category, or if you’re less than 70% confident in your routing decision, flag the ticket as ‘needs-human-review’ with an explanation of your uncertainty.”

    Iterating on SOUL.md

    Your first SOUL.md won’t be perfect. After deploying an agent, monitor its behavior. If it’s making incorrect decisions in specific scenarios, update SOUL.md to address those edge cases. If it’s too conservative (always escalating), loosen constraints. If it’s too loose (making risky decisions), tighten them.

    Treat SOUL.md as a living document. Version it alongside your agent. When you update it, test the agent’s behavior on a sample of past requests to ensure the changes have the intended effect.

    Practical Tips for Writing SOUL.md

    • Use specific numbers and thresholds. “High priority” is vague. “Priority score above 8 out of 10” is actionable.
    • Include example outputs. Show the agent what good work looks like.
    • Anticipate contradictions. If two rules might conflict (e.g., “always be fast” vs. “always be accurate”), specify which takes precedence. “When there’s a tradeoff between speed and accuracy, prioritize accuracy.”
    • Define what the agent does NOT do. Explicit “thou shalt nots” are as important as “thou shalls.”
    • Keep it readable. Use headers, bullet points, and clear language. The SOUL.md is also a document for humans to review and maintain.

    Real-World Example: SaaS Onboarding Agent

    Imagine you’re building an agent that helps new SaaS customers get started. Here’s a more complete SOUL.md:

    # SaaS Onboarding Agent

    ## Role
    You are an enthusiastic Onboarding Specialist at TechFlow (a fictional project management SaaS, $29–$199/month). Your job is to guide new customers through their first week and ensure they set up their workspace correctly.

    ## Primary Goals
    1. Get customers to their first "aha moment"—the moment they realize the product's value.
    2. Ensure they configure at least one team, one project, and one integration.
    3. Reduce time-to-first-value from 14 days (current average) to 3 days.

    ## Constraints
    - Do not offer to do the setup for them; guide them through it. (Exception: if the customer explicitly requests hands-on setup, offer a 30-min Zoom session via our calendar tool.)
    - Do not mention upcoming features or product roadmap items.
    - Do not discuss pricing changes or discounts. Route those questions to sales@techflow.com.
    - Do not provide technical support for integration issues; escalate to support@techflow.com with details.

    ## Knowledge Base Access
    You have access to: (1) our knowledge base articles, (2) video tutorials (link to each step), (3) customer success metrics for what makes an onboarding successful, (4) common blockers and solutions.

    ## Engagement Strategy
    -

    Frequently Asked Questions

    What is the primary goal of this article?

    The article aims to teach users how to write more effective and high-quality agent prompts specifically for the OpenClaw platform, enhancing their AI interactions.

    What is OpenClaw?

    Based on the title, OpenClaw is an agent or AI system that requires users to input prompts. The article focuses on optimizing these prompts for better performance.

    What is SOUL.md and its relevance?

    SOUL.md is the subject of a deep dive within the article, indicating it's a specific methodology, framework, or tool used to significantly improve the quality of agent prompts for OpenClaw.

    🤖 Get the OpenClaw Automation Starter Kit (9) →
    Instant download — no subscription needed
  • Configuring OpenClaw with Custom API Keys and Endpoints

    You’ve got a specialized model, perhaps a fine-tuned Llama-2 instance running on a private endpoint, or maybe you’re leveraging a niche provider like AI21 for specific tasks. Integrating these custom API keys and non-standard endpoints with your OpenClaw assistant isn’t just about plugging in credentials; it’s about extending your assistant’s capabilities beyond the defaults, tapping into models that offer unique strengths or better cost-efficiency for particular use cases. The problem arises when the default openai.api_key and openai.api_base configurations fall short, and you need to direct OpenClaw to an entirely different, perhaps even locally hosted, inference server with its own authentication schema.

    The standard OpenClaw configuration allows for global overrides, but for specific tools or conversational turns, you need more granular control. The key lies in understanding how OpenClaw’s tool executor context propagates. When defining a tool, you can pass a dictionary of client arguments directly to its instantiation. For example, if you’re setting up a tool that specifically interacts with your private Llama-2 endpoint, you’d define it like this: CustomLlamaTool(client_args={'api_key': 'your_private_llama_key', 'base_url': 'https://your-private-llama.com/v1'}). This isn’t just for OpenAI-compatible APIs; OpenClaw’s flexible client architecture means you can often pass provider-specific arguments here too, assuming the underlying tool wrapper supports it. A common mistake is to try and modify the global client after the assistant has been initialized, leading to inconsistent behavior or errors because tools have already captured their client configurations.

    The non-obvious insight here is that you shouldn’t fight OpenClaw’s default client behavior when you need highly specialized API access. Instead, embrace the tool-level configuration. Imagine you have a general-purpose assistant, but one specific task requires a very particular, high-latency, but extremely accurate model. Rather than forcing your entire assistant to use that endpoint and incur latency penalties for every interaction, encapsulate that model interaction within a dedicated tool. This tool, and only this tool, will then be configured with its unique API key and endpoint. This approach keeps your main assistant agile while allowing for specialized, on-demand capabilities. Furthermore, for services requiring more complex authentication than a simple API key, like OAuth tokens or custom headers, you’ll typically pass these within the client_args dictionary, often nested under a specific provider key if the tool uses a generic client interface.

    To start extending your OpenClaw assistant’s reach, identify a specific task that would benefit from a non-standard API. Then, create a new tool wrapper for that task, explicitly passing your custom api_key and base_url (or equivalent provider-specific arguments) directly within the tool’s initialization parameters.

    Frequently Asked Questions

    Why should I use custom API keys and endpoints with OpenClaw?

    Custom API keys enhance security and control access to specific services. Custom endpoints allow OpenClaw to connect to private, regional, or specialized API instances, optimizing performance, ensuring data sovereignty, or accessing beta features.

    How do I configure custom API keys and endpoints in OpenClaw?

    Configuration typically involves editing a dedicated configuration file (e.g., `openclaw.conf`), setting environment variables, or passing parameters via the command line or SDK initialization. You’ll specify your unique API key and the desired endpoint URL.

    What happens if my custom API key or endpoint changes?

    If your custom API key or endpoint changes, you must update the corresponding configuration within OpenClaw. This usually means modifying the configuration file or environment variables, then restarting the OpenClaw service or application to apply the new settings.

    Want better responses from OpenClaw? Learn how to write better agent prompts →

  • Best Privacy Routers for Home Networks in 2025

    Your router is the gateway to everything on your home network, and most ISP-provided routers are privacy nightmares. Upgrading to a privacy-focused router gives you DNS filtering, VPN support, ad-blocking, and visibility into what your devices are actually doing. Here are the best options in 2025.

    Why Your Default Router Is Not Good Enough

    • ISP routers often phone home with usage data
    • No DNS over HTTPS support (your DNS queries are visible)
    • No built-in VPN client
    • Infrequent or no security updates
    • No traffic monitoring or device blocking

    Top Privacy Routers in 2025

    1. GL.iNet Beryl AX (GL-MT3000) – Best Overall

    The GL.iNet Beryl AX (~$90) is the privacy router for most people. It runs OpenWRT under the hood, supports WireGuard and OpenVPN as a client, has AdGuard Home built-in for network-wide ad blocking, and supports DNS over HTTPS natively. Setup takes about 20 minutes via a friendly web interface.

    Pros: Easy setup, WireGuard VPN, AdGuard Home, travel-friendly size

    Cons: Better as a secondary or travel router than a primary home router

    2. Firewalla Gold Plus – Best Plug-and-Play

    The Firewalla Gold (~$200-300) is a security appliance that pairs with your existing router. It adds network monitoring, ad-blocking, VPN server and client, parental controls, and intrusion detection without replacing your router. The companion app is excellent.

    Pros: Excellent app, works with existing router, detailed network insights

    Cons: Expensive, not a full router replacement

    3. Asus RT-AX88U with Merlin Firmware – Best Performance

    The Asus RT-AX88U (~$250) running Asuswrt-Merlin firmware combines excellent WiFi 6 performance with enhanced privacy features. Merlin adds proper DNS over HTTPS, custom scripts, and better VPN configuration than stock firmware.

    Pros: Excellent performance, WiFi 6, strong Merlin firmware support

    Cons: Pricey, Merlin has a learning curve

    4. pfSense / OPNsense Box (DIY) – Most Powerful

    Building a pfSense or OPNsense router on a mini PC with dual NICs gives you enterprise-grade firewall capabilities at home. Advanced traffic shaping, VLANs, Snort and Suricata intrusion detection, and complete control. Steep learning curve but extremely powerful.

    Pros: Maximum control, enterprise features, completely customizable

    Cons: Significant learning curve, requires compatible hardware

    5. GL.iNet Flint 2 (GL-MT6000) – Best Home Router from GL.iNet

    The GL.iNet Flint 2 (~$120) is GL.iNet’s full home router with WiFi 6, a 2.5G WAN port, OpenWRT, VPN, and AdGuard Home. Better suited as a primary home router than the Beryl AX while keeping all the privacy features.

    Key Privacy Features to Look For

    DNS over HTTPS

    Encrypts your DNS queries so your ISP cannot see which domains you are visiting. Use Cloudflare (1.1.1.1) or NextDNS for a privacy-respecting resolver.

    VPN Client Support

    Router-level VPN encrypts all traffic from all devices without installing VPN apps on each one. WireGuard is much faster than OpenVPN.

    Network Ad Blocking

    AdGuard Home or Pi-hole at the router level blocks ads on every device including smart TVs and phones that cannot run traditional ad blockers.

    VLAN Support

    VLANs let you isolate IoT devices from your main network so your smart fridge cannot see your NAS or personal computers.

    Recommended Setup for Most People

    GL.iNet Flint 2 as your primary router plus NextDNS for DNS filtering. Under $150, takes an afternoon to configure, and you get network-wide ad blocking, encrypted DNS, and VPN capabilities. Add a Firewalla Gold if you want detailed traffic monitoring on top of that.

    Bottom Line

    A privacy router is one of the best investments you can make for your home network. The GL.iNet lineup offers the best balance of ease-of-use and capability for most people. Firewalla is ideal for those who want insights without replacing hardware. pfSense and OPNsense are for those who want to go deep on network control.

    Frequently Asked Questions

    What makes a router a ‘privacy router’?

    Privacy routers offer features like VPN client support, strong encryption, ad/tracker blocking, open-source firmware compatibility, and no data logging. They are designed to protect your online activities and personal information from ISPs and third parties on your home network.

    Why should I consider a privacy router for my home network in 2025?

    With increasing data surveillance and cyber threats, a privacy router helps safeguard all connected devices. It encrypts traffic, blocks unwanted access, and minimizes your digital footprint, ensuring a more secure and private online experience for your entire household.

    Are privacy routers difficult to set up or use?

    While some advanced features might require technical knowledge, many top privacy routers offer user-friendly interfaces and guided setups. Basic installation is often similar to standard routers, with additional privacy configurations becoming more intuitive over time.

    Written by: Alex Torres, Editor at OpenClaw Resource

    Last Updated: May 2026

    Our Editorial Standards | How We Review Skills | Affiliate Disclosure

    Want better responses from OpenClaw? Learn how to write better agent prompts →

  • OpenClaw Memory System Explained: How Your AI Agent Remembers

    Ever used an AI assistant only to find it completely forgets your preferences, project context, or even what you just discussed in the previous session? It’s like talking to someone with severe short-term memory loss. This stateless nature, while simple, quickly becomes a bottleneck for serious development work, requiring constant re-contextualization.

    At OpenClaw, we believe your AI agent should be more than just a fancy calculator. It should be a persistent, evolving assistant that learns and remembers—much like a human teammate. That’s why we engineered a robust, transparent, and user-centric memory system. Instead of a black-box cloud solution, OpenClaw’s memory is rooted in a file-based architecture, putting you in complete control.

    The Core Philosophy: Transparent, File-Based Memory

    The fundamental design choice for OpenClaw’s memory system is its reliance on plain, human-readable Markdown files. This isn’t just an implementation detail; it’s a philosophical stance. We reject proprietary, opaque memory stores in favor of a system that offers:

    • Full User Control: Your agent’s memories are files you own, located within your workspace (typically ~/.openclaw/workspace/ or a project-specific directory). You can read them, edit them, or even delete them directly.
    • Auditability: See exactly what your agent ‘knows’ and how it’s evolving. This is invaluable for debugging, understanding its behavior, and ensuring alignment with your goals.
    • Portability & Backup: Since they’re just files, memories are trivial to back up, sync across machines (e.g., via Dropbox, Google Drive, or even rsync), and transfer between different OpenClaw instances.
    • Searchability: Leverage standard command-line tools like grep, find, ripgrep, or even your IDE’s search functionality to query your agent’s knowledge base.
    • Version Control Friendly: Crucially, these Markdown files can be managed with Git, allowing you to track changes, revert to previous states, and even collaborate on an agent’s memory with a team.

    This transparency means you’re never guessing what your agent remembers. You can inspect its ‘brain’ directly.

    MEMORY.md: Your Agent’s Long-Term Memory (LTM)

    Think of MEMORY.md as the distilled essence of your agent’s knowledge, preferences, and core identity. This file acts as the agent’s long-term memory (LTM), and OpenClaw reads it at the beginning of every main session. It’s the equivalent of a human’s core beliefs, skills, and important learned facts.

    What goes into MEMORY.md?

    • Core Project Context: High-level goals, architecture principles, key stakeholders.
    • Personal Preferences: Your preferred coding style (e.g., “always use 4-space indentation for Python, never tabs”), toolchain (e.g., “prefer Docker Compose for local environments”), or communication style.
    • Important Facts & Decisions: Key API endpoints, database schemas, design decisions, or specific libraries to use/avoid.
    • Common Workflows: Step-by-step instructions for recurring tasks.
    • Known Limitations/Constraints: Information about system limitations or non-negotiable requirements.

    Interacting with MEMORY.md

    You can update MEMORY.md in two primary ways:

    1. Direct Editing: This is often the most precise method. Open the file in your favorite text editor (VS Code, Vim, etc.) and add or modify content.

      vim ~/.openclaw/workspace/MEMORY.md

      For instance, to ensure your agent always remembers your preferred Python linter:

      # My Python Development Preferences
      - Always use `black` for formatting.
      - Prefer `mypy` for static type checking.
      - Use `pytest` for unit and integration tests.
      - For new features, prioritize test-driven development (TDD).
    2. Via OpenClaw Commands: OpenClaw provides commands to programmatically add information to your agent’s LTM.

      openclaw remember "My primary development language is Python."
      openclaw remember "When creating REST APIs, always use FastAPI."

      These commands append to or intelligently update your MEMORY.md. Be mindful that for complex or structured information, direct editing often yields better results.

    Best Practices for MEMORY.md

    • Keep it Curated: This isn’t a dump of every conversation. It’s the distilled knowledge. Periodically review and refactor it.
    • Use Markdown Structure: Headings, bullet points, and code blocks make it easier for both you and the agent to parse.
    • Version Control It: If MEMORY.md is critical for a project, commit it to Git alongside your codebase. This allows collaboration and history tracking.
    • Security Warning: Avoid storing raw, unencrypted sensitive credentials (API keys, passwords) directly in MEMORY.md. Prefer environment variables or secure secrets management tools. If you must include hints, reference their environment variable names.

    Daily Memory Logs: The Agent’s Scratchpad (memory/YYYY-MM-DD.md)

    While MEMORY.md is the long-term knowledge, the daily memory logs (located in ~/.openclaw/workspace/memory/,

    Frequently Asked Questions

    What is the OpenClaw Memory System?

    The OpenClaw Memory System is an innovative architecture designed to provide AI agents with advanced capabilities for storing, retrieving, and processing information over extended periods, crucial for complex tasks and continuous learning.

    How does OpenClaw enable AI agents to remember?

    It uses a hierarchical and context-aware storage mechanism, allowing AI agents to efficiently recall past interactions, learned facts, and long-term knowledge. This ensures relevant information is available when needed for decision-making and task execution.

    What are the key benefits of OpenClaw for AI agents?

    OpenClaw significantly enhances an AI agent’s ability to maintain context, learn continuously, and perform complex, multi-step tasks. It improves consistency, reduces repetitive queries, and fosters more intelligent, human-like interactions and problem-solving.

    Written by: Alex Torres, Editor at OpenClaw Resource

    Last Updated: May 2026

    Our Editorial Standards | How We Review Skills | Affiliate Disclosure

    Want better responses from OpenClaw? Learn how to write better agent prompts →

  • How to Back Up Your OpenClaw Data and Memory

    OpenClaw stores everything in files — memory, skills, config, and history. This makes backup trivially simple. Here’s how to never lose your OpenClaw data.

    What OpenClaw Stores

    • MEMORY.md — curated long-term memory
    • memory/YYYY-MM-DD.md — daily session logs
    • SOUL.md, USER.md, AGENTS.md — personality and config
    • TOOLS.md — credentials and external tool config
    • HEARTBEAT.md — scheduled tasks

    All of this lives in your workspace directory (typically ~/.openclaw/workspace).

    Git Backup (Recommended)

    cd ~/.openclaw/workspace
    git init
    git remote add origin your-private-repo-url
    git add .
    git commit -m "backup"
    git push

    Add a daily cron job to auto-commit. Your entire OpenClaw state is versioned and recoverable.

    Cloud Sync

    Syncing the workspace folder to Dropbox, iCloud, or Google Drive provides automatic real-time backup. On macOS, move the workspace folder into the cloud sync directory and symlink it back.

    VPS Snapshots

    If running on a VPS, take regular snapshots. DigitalOcean makes this one click from the dashboard. A weekly automated snapshot costs pennies and gives full recovery options.

    🛒 Recommended: Automation Business Book | Productivity Desk Mat

    Written by: Alex Torres, Editor at OpenClaw Resource

    Last Updated: May 2026

    Our Editorial Standards | How We Review Skills | Affiliate Disclosure

    Want better responses from OpenClaw? Learn how to write better agent prompts →

  • How to Run OpenClaw on Windows 11 — Step by Step

    Welcome, fellow developers and AI enthusiasts, to OpenClaw Resource! Today, we’re tackling a common question: how to get OpenClaw, your personal AI assistant gateway, up and running on a local Windows 11 machine. While many opt for cloud-based deployments, running OpenClaw on your desktop can be incredibly convenient for personal use, development, and specific workflows where your PC is already active. This guide will walk you through the entire process, from prerequisites to persistent operation, with practical notes and commands.

    OpenClaw acts as a powerful intermediary, connecting various large language models (LLMs) like OpenAI’s GPT series or Anthropic’s Claude to your preferred messaging platforms such as Telegram or Discord. This means you can interact with state-of-the-art AI directly from your chat app, perfect for quick queries, content generation, code assistance, and more, all without needing to open a browser tab.

    Prerequisites: Preparing Your Windows 11 Environment

    Before we dive into OpenClaw itself, we need to ensure your Windows 11 system has the necessary foundational software. OpenClaw is a Node.js application, so that’s our first port of call.

    Install Node.js (LTS Version)

    Node.js is a JavaScript runtime environment that allows you to run JavaScript code outside of a web browser. OpenClaw relies on it. We strongly recommend installing the Long Term Support (LTS) version for stability.

    1. Download Node.js: Head over to nodejs.org/en/download. Locate the “LTS” version and download the Windows Installer (.msi file) appropriate for your system (usually 64-bit).
    2. Run the Installer: Execute the downloaded .msi file. Follow the installation wizard, accepting the default settings. The installer will also install npm (Node Package Manager), which we’ll use to install OpenClaw.
    3. Verify Installation: Once the installation is complete, open a new Command Prompt or PowerShell window. Type the following command and press Enter:
      node --version
      npm --version

      You should see version numbers for both Node.js (e.g., v18.17.1) and npm (e.g., 9.6.7). If you receive an error, double-check your installation or try restarting your terminal.

    Administrator Privileges

    Some steps, particularly the global installation of OpenClaw, require elevated permissions. It’s a good practice to open your Command Prompt or PowerShell as an Administrator for the installation phase.

    • Open as Administrator: Search for “Command Prompt” or “PowerShell” in the Windows Start menu, right-click on the application, and select “Run as administrator.”

    Installing OpenClaw Globally

    With Node.js and npm ready, installing OpenClaw is a single command. We’ll install it globally so you can run openclaw commands from any directory in your terminal.

    In your Administrator Command Prompt or PowerShell, execute:

    npm install -g openclaw

    This command uses npm to download the OpenClaw package from the npm registry and installs it in your system’s global Node.js module directory. The -g flag is crucial here. You’ll see a flurry of activity as dependencies are fetched and installed. Once it completes, you’re ready for setup.

    Initial Setup and Configuration: Connecting Your AI and Messaging

    This is where OpenClaw truly comes alive. The openclaw setup command will guide you through connecting your AI provider API keys and setting up your preferred messaging platform.

    From your Command Prompt (Administrator is not strictly required for this step, but it doesn’t hurt), run:

    openclaw setup

    You’ll be presented with a series of interactive prompts. Let’s walk through the key ones:

    1. AI Provider Configuration

    OpenClaw supports various Large Language Model (LLM) providers. You’ll likely start with one of the popular ones:

    • OpenAI: If you plan to use models like GPT-4o, GPT-4, or GPT-3.5-turbo, you’ll need an OpenAI API key. Get yours from platform.openai.com/api-keys. Enter it when prompted. Example prompt: Enter your OpenAI API Key (leave blank to skip): sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    • Anthropic: For models like Claude 3 Opus, Sonnet, or Haiku, an Anthropic API key is required. Obtain it from console.anthropic.com/settings/api-keys. Example prompt: Enter your Anthropic API Key (leave blank to skip): sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    • Other Providers: OpenClaw may support other providers. Follow the prompts accordingly.

    You can configure multiple providers; OpenClaw will ask for each in turn. It’s recommended to set up at least one to make your assistant functional.

    2. Messaging Platform Configuration

    Next, you’ll configure how you want to interact with OpenClaw. Telegram and Discord are common choices:

    • Telegram Bot: This is a popular and robust option.
      1. Create a Bot: Open Telegram and search for @BotFather. Start a chat and send /newbot. Follow BotFather’s instructions to name your bot and give it a username.
      2. Get Bot Token: BotFather will provide you with an HTTP API token (e.g., 123456789:AABBCCDD-EEFFGGHHIIJJKKLLMMNNOOPP). Copy this token.
      3. Enter Token in OpenClaw Setup: When OpenClaw prompts for a Telegram Bot Token, paste it in.
      4. Start Your Bot: Go to your newly created bot in Telegram and send it a /start message. This initializes the chat, making it ready for OpenClaw.
    • Discord Bot: For Discord integration:
      1. Create an Application: Go to the Discord Developer Portal. Click “New Application,” give it a name, and create it.
      2. Create a Bot User: In your application’s settings, navigate to “Bot” on the left sidebar. Click “Add Bot.” Confirm.
      3. Get Bot Token: Under the “Token” section, click “Reset Token” and copy the new token. Keep this token secret!
      4. Configure Intents: Scroll down to “Privileged Gateway Intents” and enable MESSAGE CONTENT INTENT. This is crucial for the bot to read messages.
      5. Invite Bot to Server: Go to “OAuth2” -> “URL Generator.” Select bot scope. Under “Bot Permissions,” grant necessary permissions (e.g., “Send Messages,” “Read Message History”). Copy the generated URL and paste it

        Written by: Alex Torres, Editor at OpenClaw Resource

        Last Updated: May 2026

        Our Editorial Standards | How We Review Skills | Affiliate Disclosure

        Want better responses from OpenClaw? Learn how to write better agent prompts →