Category: Uncategorized

If you’ve been using OpenClaw for a while, you’re likely familiar with its prowess in tackling complex, multi-step tasks that traditional AI tools struggle with. While Large Language Models (LLMs) are fantastic at generating text and reasoning, they hit a wall when they need to *act* on that reasoning within a dynamic, real-world web environment. This is where OpenClaw’s browser automation capabilities shine, enabling it to go beyond simple API calls and actually interact with web applications like a human would. This isn’t just about filling out a form; it’s about navigating intricate workflows, handling edge cases, and even extracting data from notoriously difficult, JavaScript-heavy sites that APIs often don’t expose.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Beyond Simple Forms: Dynamic Workflow Automation

Most “AI automation” tools that claim to interact with browsers are often just glorified form-fillers or screen scrapers. They operate on a fixed set of elements, expecting the page to always look a certain way. OpenClaw, however, leverages a sophisticated understanding of the DOM and visual context, allowing it to adapt to changes and perform truly dynamic workflows. Consider a scenario where you need to onboard a new employee by creating accounts across multiple internal systems. This isn’t just about filling out a name and email. It involves: logging into an HR portal, navigating to “New Employee” section, filling out initial details, clicking “Save,” then waiting for the page to reload, identifying a newly appeared “Create IT Accounts” button, clicking that, navigating to another system, logging in again (potentially with SSO), finding the user creation form, populating it with data from the HR portal, handling potential CAPTCHAs, and confirming creation. Each step might involve different page layouts, dynamic IDs, and conditional elements.

Here’s a practical example. Let’s say you want OpenClaw to search for job postings on LinkedIn, filter them by specific criteria, and then click into each promising job to extract the full description, company details, and application link. A typical approach might involve using the LinkedIn API, but that’s rate-limited and doesn’t expose all the data you need, especially custom fields in job descriptions. OpenClaw can do this by literally browsing:

// in your .openclaw/tasks/linkedin_job_search.json

{
  "name": "LinkedIn Job Search and Extract",
  "description": "Searches LinkedIn for jobs, filters, and extracts details.",
  "steps": [
    {
      "action": "navigate",
      "url": "https://www.linkedin.com/jobs/"
    },
    {
      "action": "type",
      "selector": "input[aria-label='Search by title, skill, or company']",
      "value": "Software Engineer"
    },
    {
      "action": "click",
      "selector": "button[type='submit']"
    },
    {
      "action": "waitForSelector",
      "selector": ".jobs-search-results__list"
    },
    {
      "action": "type",
      "selector": "input[aria-label='Location']",
      "value": "Remote"
    },
    {
      "action": "click",
      "selector": "button[data-test-app-id='job-filters-panel-job-type-filter']"
    },
    {
      "action": "click",
      "selector": "input[id='remote-filter-checkbox']"
    },
    {
      "action": "click",
      "selector": "button[data-control-name='apply_filters']"
    },
    {
      "action": "extract",
      "selector": ".jobs-search-results__list-item",
      "loop": {
        "title": ".job-card-list__title",
        "company": ".job-card-list__company-name",
        "link": {
          "selector": ".job-card-list__title",
          "attribute": "href"
        },
        "details": {
          "action": "navigate",
          "selector": "{link}",
          "steps": [
            {
              "action": "waitForSelector",
              "selector": ".job-details-js-description"
            },
            {
              "action": "extract",
              "selector": ".job-details-js-description",
              "type": "text"
            }
          ]
        }
      }
    }
  ],
  "output": "extracted_data.json"
}

This snippet demonstrates navigating, typing, clicking, waiting for elements, and crucially, looping through search results to click on each one and then extract nested data from a new page. This kind of multi-page, conditional interaction is where OpenClaw truly excels over simpler web automation tools.

Handling JavaScript-Heavy SPAs and Dynamic Content

Many modern web applications are Single Page Applications (SPAs) built with frameworks like React, Angular, or Vue.js. These sites load content dynamically, often after user interactions, and their DOM structure can change significantly. Traditional scrapers that rely on static HTML parsing fall flat here. OpenClaw, by running a full headless browser (e.g., Chromium), fully renders the page, executes JavaScript, and waits for content to appear. This is critical for:

• Login Flows with Multi-Factor Authentication (MFA): OpenClaw can detect the MFA prompt, wait for user input (if configured for human-in-the-loop), or even integrate with TOTP generators if the token is available.
• Infinite Scrolling Pages: Instead of being limited to the first few results, OpenClaw can scroll down, trigger more content to load, and then continue processing.
• Interactive Dashboards: Imagine needing to extract data from a dashboard where filters need to be applied, charts need to be clicked to reveal underlying data, or tables need to be paginated. OpenClaw can perform these actions sequentially.

The non-obvious insight here is that while the OpenClaw docs mention using a full browser, many users initially try to optimize by using simpler HTTP requests or less resource-intensive methods. For anything beyond basic static page scraping, *always* default to using the full browser context ("browser": true in your task or openclaw --browser). Attempting to shortcut this on complex SPAs will lead to inconsistent results and frustrating debugging sessions. The overhead is worth the reliability.

Limitations and Resource Considerations

While powerful, OpenClaw’s browser automation is resource-intensive. Running a headless Chromium instance consumes significant CPU and RAM. This is not suitable for a Raspberry Pi or any VPS with less than 2GB of RAM. For consistent operation, especially with multiple concurrent browser tasks or complex navigations, I recommend a VPS with at least 4GB RAM and 2 vCPUs. If you’re running OpenClaw on your local machine, ensure you have sufficient resources available. Overcommitting resources can lead to the browser crashing or tasks timing out, especially during periods of high load on the target website.

Another limitation is CAPTCHA handling. While OpenClaw can integrate with services like 2Captcha or Anti-Captcha, this adds cost and complexity. For very high-volume automation, you might hit rate limits or be flagged more frequently by anti-bot measures. OpenClaw provides the tools to manage these, but it’s an arms race with site operators.

Finally, for long-running tasks, network reliability is key. A dropped connection during a critical step can leave your automation in an undefined state. Implement robust error handling (which OpenClaw supports through conditional steps and retries) and consider proxy rotation if you’re hitting IP-based blocks.

The true power of OpenClaw’s browser automation lies in its ability to mimic human interaction on a broad range of websites, going far beyond what APIs or simple HTTP requests can achieve. It’s the difference between asking a question and actually demonstrating how to solve a problem.

To start automating with the browser, ensure your task configuration includes "browser": true for any step requiring browser interaction, like this:

{
  "action": "navigate",
  "url": "https://example.com",
  "browser": true
}

Frequently Asked Questions

If you’re running OpenClaw on a remote server, perhaps a DigitalOcean Droplet or a self-hosted Ubuntu machine, and you’ve noticed that your OpenClaw processes stop as soon as your SSH session disconnects, you’re not alone. This isn’t an OpenClaw specific issue, but a fundamental aspect of how processes are managed in a typical Linux environment. When you log out of SSH, the shell sends a SIGHUP (Hangup) signal to all processes that are children of the shell. Unless these processes are specifically configured to ignore this signal, they will terminate. This guide will walk you through a robust solution using PM2 for process management and systemd for ensuring PM2 itself starts automatically on boot.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Understanding the Problem: SIGHUP and Shell Sessions

When you execute openclaw start from your SSH terminal, OpenClaw runs as a child process of your shell session. The shell, usually Bash or Zsh, acts as the parent. If you close your terminal window, lose your internet connection, or explicitly type exit, the shell process terminates. As a courtesy (or often, a necessity), the shell then sends a SIGHUP signal to its child processes. Many programs, including OpenClaw by default, are configured to interpret SIGHUP as a command to shut down. This is why your OpenClaw instance goes offline when you disconnect. While tools like nohup or screen/tmux can help, they are often stop-gap measures. nohup can be finicky with complex applications, and screen/tmux require manual re-attachment, which isn’t ideal for long-running services.

Introducing PM2: A Production Process Manager for Node.js Applications

PM2 is a production process manager for Node.js applications with a built-in load balancer. While OpenClaw isn’t strictly a Node.js application (it’s Python), PM2 is incredibly versatile and can manage any arbitrary command. It handles daemonization, logging, automatic restarts, and clustering, making it perfect for keeping OpenClaw alive. Its key feature for our use case is its ability to detach processes from the current shell, making them immune to SIGHUP signals.

First, ensure you have Node.js and npm installed on your server. If not, the easiest way on Ubuntu/Debian is:

sudo apt update
sudo apt install -y nodejs npm

Then, install PM2 globally:

sudo npm install pm2 -g

Now, instead of running OpenClaw directly, we’ll use PM2 to manage it. Navigate to your OpenClaw installation directory (e.g., /opt/openclaw or wherever you cloned it). Replace python3 main.py start with your actual OpenClaw start command if it’s different. Make sure you’re in the OpenClaw root directory.

cd /path/to/your/openclaw/directory
pm2 start "python3 main.py start" --name "openclaw"

The --name "openclaw" flag gives your OpenClaw process a friendly name in PM2, making it easier to manage. After running this, you can immediately disconnect your SSH session. When you reconnect and run pm2 list, you should see your OpenClaw process listed as “online”.

Persisting Processes Across Reboots with PM2 and systemd

While PM2 keeps OpenClaw running after an SSH disconnect, it doesn’t automatically restart your processes if the server itself reboots. For that, we need to integrate PM2 with systemd, the init system used by most modern Linux distributions. PM2 has a built-in command to generate a systemd unit file.

pm2 startup systemd

This command will output instructions that are specific to your system and user. It usually looks something like this:

[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/usr/bin /usr/local/lib/node_modules/pm2/bin/pm2 startup systemd -u your_username --hp /home/your_username

Make sure to copy and execute the command exactly as PM2 outputs it, replacing your_username with your actual username. This command creates a systemd service file (e.g., ~/.config/systemd/user/pm2-your_username.service or similar) that will start PM2 at boot. It also enables and starts this service.

After generating the startup script, you need to save your currently running PM2 processes so they are automatically restored on reboot:

pm2 save

Now, if your server reboots (e.g., due to a software update or power outage), PM2 will start automatically, and then PM2 will restart your OpenClaw process. You can verify the systemd service status with:

systemctl --user status pm2-your_username.service

Remember to replace your_username. The --user flag is crucial here because PM2 typically generates a user-level systemd service, not a system-wide one.

Non-Obvious Insight: Logging and Resource Management

One common pitfall when running OpenClaw with PM2 is neglecting log management. PM2 automatically captures stdout and stderr, but if you have high-volume logging, these log files can grow indefinitely and consume disk space. By default, PM2 logs are stored in ~/.pm2/logs/. It’s a good practice to set up log rotation for these files. While PM2 has a pm2-logrotate module, for simplicity, you can also manage this with a standard system-wide logrotate configuration. Create a file like /etc/logrotate.d/pm2:

/home/your_username/.pm2/logs/*.log {
    daily
    missingok
    rotate 7
    compress
    delaycompress
    notifempty
    create 0640 your_username your_username
    sharedscripts
    postrotate
        pm2 reloadLog 'openclaw' > /dev/null
    endscript
}

Replace your_username with your actual username. This configuration rotates logs daily, keeps 7 compressed old logs, and tells PM2 to reload its log streams after rotation, preventing data loss. Also, keep an eye on OpenClaw’s own resource usage. While PM2 is lightweight, OpenClaw itself, especially with complex model interactions or high concurrency, can be memory-intensive. This setup works best on a VPS with at least 1GB of RAM dedicated to OpenClaw and the OS. On a Raspberry Pi, especially older models, you might run into memory swap issues if your OpenClaw configuration is demanding, leading to instability or slow responses. Always monitor your RAM and CPU usage with htop or free -h.

The exact next step you should take to secure your OpenClaw instance is to run pm2 save in your OpenClaw directory to ensure your current configuration is persisted across server reboots.

Frequently Asked Questions

If you’re running OpenClaw on a Hetzner VPS and are looking to extend its capabilities beyond the core models, you’ve likely browsed the official OpenClaw Skills Directory. The directory is a treasure trove, but not all skills are created equal, especially when it comes to resource usage and practical utility in a typical self-hosted environment. I’ve spent the last few months experimenting with various community contributions, and I want to highlight the ones that genuinely enhance OpenClaw’s functionality without turning your VPS into a molten core, or requiring a PhD in prompt engineering to get them working.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Managing External APIs with the api_proxy Skill

One of the most powerful, yet often overlooked, skills is api_proxy. Its primary purpose is to act as a secure, authenticated gateway for other skills to interact with external APIs. For instance, if you want your OpenClaw instance to fetch real-time stock prices or weather data, you don’t want to embed API keys directly into multiple skills or expose them in plain text. The api_proxy skill allows you to centralize your API key management and ensures that only authorized OpenClaw skills can make requests. This is crucial for maintaining security and preventing accidental key exposure, which is a common oversight when integrating third-party services.

To set it up, you’ll first need to install the skill:

openclaw install api_proxy

Then, configure your API keys in ~/.openclaw/skills/api_proxy/config.json. A typical configuration for, say, a weather API and a stock market API might look like this:

{
  "api_keys": {
    "openweather": "YOUR_OPENWEATHER_API_KEY",
    "alphavantage": "YOUR_ALPHAVANTAGE_API_KEY"
  },
  "endpoints": {
    "openweather": "https://api.openweathermap.org/data/2.5/weather",
    "alphavantage_daily": "https://www.alphavantage.co/query?function=TIME_SERIES_DAILY"
  }
}

Now, any other skill can request data through api_proxy by specifying the endpoint name and passing parameters. This centralizes sensitive credentials and simplifies the development of other skills that rely on external data. The non-obvious insight here is that while the documentation might suggest this for complex scenarios, it’s immensely useful even for simple integrations. It abstracts away the API key management from the individual skill logic, making your setup cleaner and more robust against configuration errors or security lapses. This skill is relatively lightweight and doesn’t demand significant RAM, making it perfect for most VPS setups.

Enhanced Search with serp_google

While OpenClaw has basic web browsing capabilities, the serp_google skill takes it to another level by integrating with the Google Custom Search API. This provides a more structured and often more relevant search experience compared to simple HTTP fetching. It’s particularly useful when OpenClaw needs to access up-to-date information that isn’t present in its training data or local knowledge base.

Installation is straightforward:

openclaw install serp_google

You’ll need a Google API key and a Custom Search Engine ID. The setup process for these can be a bit tedious on Google’s developer console, but it’s a one-time effort. Configure these in ~/.openclaw/skills/serp_google/config.json:

{
  "api_key": "YOUR_GOOGLE_API_KEY",
  "cx": "YOUR_CUSTOM_SEARCH_ENGINE_ID"
}

The key insight here is to configure your Custom Search Engine to target specific, high-quality websites relevant to your primary use case. For example, if you use OpenClaw for coding assistance, configure the CSE to search documentation sites like Stack Overflow, MDN, or official language docs. This dramatically improves the relevance of search results and reduces the “noise” from generic web searches. While the default model might struggle to parse vast amounts of raw HTML, serp_google provides structured JSON results, which are much easier for OpenClaw to process. This skill will consume a bit more network bandwidth due to API calls, but the processing overhead on the VPS itself is minimal.

Simplifying File Management with file_system_explorer

For those using OpenClaw for local development or system administration tasks on the same machine, the file_system_explorer skill is invaluable. It provides a controlled interface for OpenClaw to list directories, read file contents, and even perform basic file operations. This is incredibly useful for tasks like debugging configuration files, reviewing log files, or even scaffolding new project structures based on your prompts.

Install it like any other skill:

openclaw install file_system_explorer

The critical configuration for this skill is defining the allowed paths. For security reasons, you absolutely do not want OpenClaw to have unfettered access to your entire filesystem. Configure ~/.openclaw/skills/file_system_explorer/config.json with specific allow-lists:

{
  "allowed_paths": [
    "/home/youruser/projects",
    "/var/log/openclaw",
    "/tmp/openclaw_data"
  ],
  "read_only_paths": [
    "/etc/openclaw"
  ],
  "max_file_size_bytes": 1048576,
  "max_dir_depth": 5
}

The non-obvious insight: always start with a very restrictive allowed_paths list and expand it incrementally as needed. Using read_only_paths for sensitive configuration directories (like /etc/openclaw) ensures OpenClaw can inspect but not modify critical system files. This skill is generally light on resources as file operations are handled by the underlying OS, but be mindful of reading extremely large files, which could consume significant memory depending on your OpenClaw model’s context window. This skill only works effectively if your VPS has at least 2GB of RAM, as smaller instances might struggle if OpenClaw attempts to load large file contents into its context.

The OpenClaw Skills Directory is a powerful resource, but careful selection and configuration are key to getting the most out of your self-hosted instance without over-provisioning resources. These three skills provide a solid foundation for enhancing your OpenClaw’s capabilities in security, information retrieval, and local system interaction.

Your immediate next step should be to install the api_proxy skill and configure an API key for a service you frequently use by running: openclaw install api_proxy && nano ~/.openclaw/skills/api_proxy/config.json.

Frequently Asked Questions

If you’re looking to run OpenClaw 24/7 and are evaluating VPS hosts like Hetzner, DigitalOcean, or Vultr, you’ve likely encountered the promise of cheap, always-on compute. The reality, especially with long-running AI inference tasks, can be a bit more nuanced than the marketing suggests. This guide cuts through the noise to give you practical advice based on real-world OpenClaw deployments.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Hetzner Cloud: The Price-Performance King (with a Catch)

Hetzner Cloud often comes out on top for raw price-performance, especially with their “Falkenstein” (Germany) and “Helsinki” (Finland) data centers. For an OpenClaw instance, you’re primarily concerned with CPU stability, RAM, and consistent network throughput to your model API (e.g., Anthropic, OpenAI). A typical OpenClaw setup monitoring a few dozen RSS feeds and performing summarization, classification, and webhook notifications can comfortably run on a CPX11 instance (2 vCPU, 2GB RAM) costing around €4.30/month.

However, there’s a significant catch: Hetzner’s CPU fair-use policy. While not explicitly stated for individual vCPUs, their shared CPU instances can experience “noisy neighbor” issues, leading to unpredictable performance dips, especially during peak hours. More critically for OpenClaw, if your instance consistently hits high CPU usage (e.g., from frequent, complex model calls or parallel processing of many feeds), Hetzner’s automated systems might throttle your instance or, in rare cases, flag it for resource abuse. I’ve personally seen OpenClaw instances on CPX11 exhibit unexplained slowdowns and occasional outright crashes overnight, often recovering on their own, suggesting temporary resource contention. This is less of an issue if your OpenClaw instance is mostly idle, polling every few minutes. But if you’re running large language models locally (which is not recommended for these small VPS types), or processing hundreds of requests per minute, you will hit this limit.

To mitigate this on Hetzner, if you find your OpenClaw instance becoming unresponsive or showing high load average without obvious OpenClaw activity, you might need to upgrade to a dedicated core instance or, more practically for OpenClaw, ensure your interval settings in .openclaw/config.json are sufficiently high to prevent constant CPU spikes. For example, if you’re polling 50 feeds, setting "interval": "5m" (5 minutes) instead of "interval": "1m" can make a huge difference.

Here’s an example of a good starting .openclaw/config.json for Hetzner, emphasizing efficiency:

{
  "api_key": "YOUR_ANTHROPIC_API_KEY",
  "default_model": "claude-haiku-20240307",
  "base_url": "https://api.anthropic.com/v1",
  "interval": "5m",
  "max_concurrent_tasks": 5,
  "data_directory": "/var/lib/openclaw",
  "plugins": [
    {
      "name": "rss_ingestor",
      "config": {
        "feeds": [
          {"url": "https://example.com/feed1.xml", "tags": ["tech", "news"]},
          {"url": "https://example.org/feed2.xml", "tags": ["ai", "research"]}
        ]
      }
    },
    {
      "name": "webhook_notifier",
      "config": {
        "url": "https://your-webhook-endpoint.com/receive",
        "method": "POST"
      }
    }
  ]
}

The non-obvious insight here: while Hetzner’s documentation might imply that 2 vCPUs are equivalent to 2 full cores, in shared environments, they are not. For OpenClaw, prioritize stable, consistent CPU over burst performance if your budget forces you onto shared plans. Also, consider their dedicated core options like CCX12 if you need guarantees, but that pushes the price up significantly.

DigitalOcean Droplets: Predictable Performance, Higher Cost

DigitalOcean offers a more predictable experience, especially with their “Basic” droplets. A 1GB Memory / 1 vCPU droplet starts around $6/month, which is comparable to Hetzner’s CPX11 but often feels more stable under sustained load. Their “Premium AMD” droplets offer even better single-core performance, which is beneficial for OpenClaw’s largely single-threaded core processing of items before offloading to model APIs.

I’ve found DigitalOcean to be more forgiving with consistent CPU usage. If your OpenClaw instance is frequently polling and processing, a $6/month or $8/month droplet provides a smoother experience than a similarly priced Hetzner shared CPU instance. The main trade-off is the cost per resource unit; you generally pay more for the same raw specs compared to Hetzner.

DigitalOcean’s monitoring is also quite good, allowing you to easily track CPU utilization and I/O, which helps diagnose OpenClaw performance issues. If you see persistent 100% CPU usage, it’s a clear indicator that your max_concurrent_tasks or interval settings are too aggressive for your chosen droplet size, or you have a plugin misbehaving. The non-obvious insight: DigitalOcean’s network performance to major API endpoints (e.g., Anthropic, OpenAI) tends to be very consistent, which is crucial for reducing latency on LLM calls. This translates to faster overall processing per item.

A Raspberry Pi will absolutely struggle with OpenClaw. Even a Pi 4 with 8GB RAM will be bottlenecked by its slower CPU architecture and I/O compared to x86/x64 VPS options. This applies equally to DigitalOcean, Hetzner, and Vultr: stick to x86/x64 for OpenClaw.

Vultr Cloud Compute: A Balanced Middle Ground

Vultr positions itself somewhere between Hetzner and DigitalOcean in terms of pricing and features. Their “Cloud Compute” plans are competitive, with a 1 vCPU, 1GB RAM instance starting at $6/month. Vultr’s network quality is generally excellent, and I’ve experienced very stable CPU performance on their shared plans, often feeling more akin to DigitalOcean than Hetzner in terms of predictability under load.

One area where Vultr shines for OpenClaw is their global data center presence. If your primary API endpoints or webhook targets are geographically diverse, Vultr likely has a data center closer to them, potentially reducing latency. This can be critical if you’re chaining OpenClaw with other services that are sensitive to network delays.

The non-obvious insight: Vultr’s single-core performance on their standard plans tends to be very good for the price. This is beneficial for OpenClaw’s primary loop, which iterates through items and dispatches tasks. A strong single core reduces the time spent on the main thread, allowing the asynchronous tasks to complete more quickly. Always consider the CPU clock speed and single-core benchmark if you have a choice. Often, a “faster” 1 vCPU instance will outperform a “slower” 2 vCPU instance for typical OpenClaw workloads.

Choosing the Right Host for Your OpenClaw Deployment

For most OpenClaw users running a standard configuration (RSS ingest, LLM summarization/classification, webhook notification) with up to ~100 feeds and a few thousand items per day, a VPS with 2GB RAM and 1-2 vCPUs is sufficient. This only works if you’re on a VPS with at least 2GB RAM. Raspberry Pi will struggle due to its limited processing power and I/O. For the LLM models, I strongly recommend using external APIs like Anthropic’s Claude Haiku. It’s not just about cost; running a reasonable LLM locally on a small VPS is generally unfeasible due to RAM and CPU requirements.

Specifically, the docs might default to a model like claude-3-opus-20240229 for examples, but claude-haiku-20240307 (or its latest iteration) is usually 10x cheaper and good enough for 90% of tasks like summarization, sentiment analysis, and basic classification. Always configure your default_model accordingly to save costs.

If you’re budget-constrained and willing to tolerate occasional, minor performance fluctuations, Hetzner’s CPX11 or CPX21 are hard to beat on price. If predictability and consistent performance are paramount, and you don’t mind paying

Frequently Asked Questions

If you’re running OpenClaw for any period, especially for tasks that require ongoing context like customer support bots or long-form content generation, you’ve likely hit a wall with the AI forgetting previous interactions. This isn’t just frustrating; it leads to repetitive queries, incoherent responses, and ultimately, a less useful agent. The core of the problem is that Large Language Models (LLMs) are stateless by nature; each API call is a fresh start unless you explicitly provide conversational history. OpenClaw addresses this with its innovative MEMORY.md system, providing persistent context that goes beyond the typical API call window.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

The Problem with Stateless LLMs

Most interactions with LLMs are transient. You send a prompt, you get a response, and that’s the end of that particular interaction from the LLM’s perspective. If you want the AI to remember something from a previous turn, you have to concatenate the entire conversation history into the next prompt. This quickly becomes problematic for several reasons:

• Token Limits: Every LLM has a maximum context window, measured in tokens. As conversations grow, you quickly hit this limit, forcing you to truncate history, leading to the AI “forgetting.”
• Cost: Paying for tokens means paying for every word, even those repeated from previous turns. Longer contexts mean higher API costs.
• Complexity: Manually managing conversation history in your application logic adds significant overhead.

OpenClaw’s MEMORY.md system is designed to provide a more robust and persistent form of memory, allowing the AI to maintain a long-term understanding of its purpose, past interactions, and evolving knowledge base, without constantly resending entire conversation logs.

How MEMORY.md Works

MEMORY.md isn’t just a simple log of past conversations. It’s a curated, editable representation of the AI’s evolving understanding. It lives in your agent’s directory, for example, my_agent/MEMORY.md. This file is parsed by OpenClaw and injected into the LLM’s context during each interaction, but in a smart, summarized way. The key here is that it’s not a verbatim transcript of everything said, but rather a structured summary of crucial information.

When an agent runs, OpenClaw first loads the MEMORY.md file. This file contains key information about the agent’s identity, objectives, and any critical long-term context. After each interaction where the agent generates a response, OpenClaw takes the new information, combines it with the existing MEMORY.md, and then uses a separate LLM call (or a heuristic) to update MEMORY.md. This update process is crucial; it distills new information into a concise format that fits within the context window for future interactions. This is the non-obvious insight: you’re not just appending to a file; you’re actively summarizing and refining the agent’s knowledge.

Consider an agent designed to help users troubleshoot network issues. Initially, MEMORY.md might contain:

# Agent Identity
You are NetAssist, an AI specialized in diagnosing and resolving home network problems.

# Core Capabilities
Provide step-by-step troubleshooting for common issues (Wi-Fi, no internet, slow speeds).
Ask clarifying questions to narrow down problems.
Recommend basic hardware resets and configuration checks.

# Known Issues & Solutions (Updated: 2023-10-26)
Wi-Fi dropping frequently: Suggest checking router firmware, channel interference, or updating device drivers.
No internet access: Check modem lights, router connections, ISP status page.

After a user interaction where the agent successfully helps a user diagnose a specific brand of router’s known firmware bug, the MEMORY.md might be updated by OpenClaw to include:

# Agent Identity
You are NetAssist, an AI specialized in diagnosing and resolving home network problems.

# Core Capabilities
Provide step-by-step troubleshooting for common issues (Wi-Fi, no internet, slow speeds).
Ask clarifying questions to narrow down problems.
Recommend basic hardware resets and configuration checks.

# Known Issues & Solutions (Updated: 2023-10-27)
Wi-Fi dropping frequently: Suggest checking router firmware, channel interference, or updating device drivers.
No internet access: Check modem lights, router connections, ISP status page.
TP-Link Archer AX50 firmware bug: If user reports internet dropping after 30-60 minutes, advise checking for firmware version 1.1.0 or higher. Known issue with older firmware.

This iterative refinement ensures that the agent’s knowledge base grows organically and remains relevant without exceeding token limits or incurring massive costs. It’s not just a chat log; it’s a dynamic knowledge graph represented in Markdown.

Configuration and Customization

The behavior of the MEMORY.md system can be configured in your agent’s .openclaw/config.json file. While OpenClaw generally does a good job with default settings, you might want to fine-tune it based on your agent’s task. For example, you can specify which LLM model to use for the memory update process, or even disable it if you have a very simple, stateless agent.

Here’s an example snippet you might find in .openclaw/config.json:

{
  "agent_name": "NetAssist",
  "llm_provider": "anthropic",
  "llm_model": "claude-opus-20240229",
  "memory_management": {
    "enabled": true,
    "update_model": "claude-haiku-20240307",
    "update_prompt_template": "summarize_memory_template.md",
    "max_memory_size_tokens": 2000,
    "auto_update_after_turns": 5
  }
}

The non-obvious insight here is the update_model. While your primary llm_model might be a high-end, expensive model like claude-opus-20240229 for complex reasoning, you can use a much cheaper, faster model like claude-haiku-20240307 for the memory update process. Haiku is incredibly efficient for summarization tasks and can save you significant API costs, especially for agents with high interaction volumes. For 90% of memory summarization tasks, Haiku is more than sufficient and can be 10x cheaper than Opus.

update_prompt_template points to a file that defines how OpenClaw should instruct the LLM to update the memory. You can customize this to guide the summarization process, emphasizing certain types of information or maintaining a specific structure in your MEMORY.md.

max_memory_size_tokens helps prevent memory bloat, ensuring your MEMORY.md doesn’t grow indefinitely, which would eventually exceed even the summarization model’s context window. auto_update_after_turns dictates how often the memory update process is triggered. For agents with frequent, short interactions, you might set this lower (e.g., 1 or 2 turns). For agents with longer, less frequent interactions, a higher number might be appropriate to reduce API calls.

Limitations

While the MEMORY.md system is powerful, it’s not a silver bullet. The effectiveness of the summarization and update process depends heavily on the quality of the LLM used for update_model and the clarity of your update_prompt_template. If your agent is running on a resource-constrained device, such as a Raspberry Pi with less than 2GB of RAM, running frequent memory updates with even a Haiku model can still be slow due to the network latency and processing overhead. For such environments, you might need to increase auto_update_after_turns significantly or opt for more infrequent, manual memory updates.

Also, MEMORY.md is primarily designed for structured, long-term memory. It’s not a substitute for the immediate, short-term conversational context that LLMs handle within a single turn. For very nuanced, real-time context transfer between turns, you’ll still rely on the LLM’s direct context window, but MEMORY.md provides the foundational knowledge that informs those immediate interactions.

Ultimately, MEMORY.md transforms OpenClaw agents from stateless automatons into entities with a persistent, evolving understanding of their purpose and past. This dramatically improves continuity, reduces token waste, and enables more sophisticated, long-running AI applications.

To start leveraging this, ensure your agent’s