Category: Developer Tools

If you’re running OpenClaw on a Hetzner VPS and finding yourself manually kicking off routine tasks, or worse, forgetting them entirely, then you’re missing out on the power of the OpenClaw Python SDK. While the UI is great for interactive exploration and quick prompts, many production workflows demand automation. Think daily sentiment analysis reports, scheduled content generation, or even complex multi-step agents that interact with external APIs. Manually copying and pasting prompts into the UI just isn’t scalable or reliable. This note will walk you through how to script OpenClaw using its Python SDK to automate these repetitive tasks, focusing on practical examples you can adapt for your own use cases.

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.

Setting Up Your Python Environment

Before we dive into the code, ensure your Python environment is ready. You’ll need Python 3.8+ and the openclaw SDK installed. If you’re working on a fresh Hetzner Ubuntu instance, you can typically get Python up and running with:

sudo apt update
sudo apt install python3-pip -y
pip3 install openclaw

You’ll also need your OpenClaw API key. This isn’t usually stored in a public Git repository, so the best practice is to load it from an environment variable. Add this to your ~/.bashrc or ~/.profile on your VPS:

export OPENCLAW_API_KEY="sk_your_api_key_here"

Remember to source your profile after adding it: source ~/.bashrc. The OpenClaw SDK will automatically pick up this environment variable, saving you from hardcoding it in your scripts.

Basic Interaction: Generating Text

Let’s start with a simple script to generate some text. Create a file named generate_report.py:

import os
from openclaw import OpenClaw

# Initialize the client. It will automatically pick up OPENCLAW_API_KEY from environment variables.
client = OpenClaw()

def generate_daily_summary(topic: str) -> str:
    """Generates a brief daily summary for a given topic."""
    prompt = f"Write a concise daily news summary about {topic}, focusing on key developments from the last 24 hours. Keep it under 150 words."
    response = client.completions.create(
        model="claude-haiku-4-5", # A cost-effective model for summaries
        prompt=prompt,
        max_tokens=200, # Max tokens for the model's response
        temperature=0.7 # A bit of creativity
    )
    return response.text

if __name__ == "__main__":
    summary = generate_daily_summary("AI in healthcare")
    print("--- Daily AI in Healthcare Summary ---")
    print(summary)

    # Example: Saving to a file
    with open("ai_healthcare_summary.txt", "w") as f:
        f.write(summary)
    print("\nSummary saved to ai_healthcare_summary.txt")

The non-obvious insight here is the model choice. While the OpenClaw documentation might suggest using the latest and greatest models like claude-opus-4-0, for many routine summarization or classification tasks, a smaller, faster, and significantly cheaper model like claude-haiku-4-5 is often more than sufficient. It’s about 10x cheaper per token and provides excellent quality for 90% of use cases where extreme nuance isn’t critical. Always test cheaper models first to see if they meet your needs.

To run this script:

python3 generate_report.py

Automating with Cron Jobs

Now that we have a script, the next logical step is to automate its execution. Cron is your friend here on a Linux VPS. Let’s say you want to run this daily summary script every morning at 7:00 AM.

First, ensure your Python script has the correct shebang and is executable:

chmod +x generate_report.py

Then, edit your crontab:

crontab -e

Add the following line:

0 7 * * * /usr/bin/python3 /path/to/your/scripts/generate_report.py >> /var/log/openclaw_reports.log 2>&1

A crucial detail for cron jobs is ensuring the environment variables are correctly loaded. The OPENCLAW_API_KEY won’t automatically be available to cron jobs unless you explicitly define it in the crontab or source your profile within the script itself. A safer approach for cron is to pass the key directly to the script, or make sure the cron user’s environment is set up. For simplicity, if your script directly uses the SDK, it’s better to ensure the cron job runs with the necessary environment. Alternatively, you can explicitly set it within the cron entry:

0 7 * * * OPENCLAW_API_KEY="sk_your_api_key_here" /usr/bin/python3 /path/to/your/scripts/generate_report.py >> /var/log/openclaw_reports.log 2>&1

Or, even better, ensure your script itself handles the environment variable gracefully, as shown in the Python example where it automatically picks it up. The output redirection >> /var/log/openclaw_reports.log 2>&1 is vital for debugging cron jobs; without it, you’ll have no idea if your script ran successfully or failed silently.

Handling More Complex Workflows: Multi-Turn Conversations

The OpenClaw SDK also supports multi-turn conversations, which are essential for building more dynamic agents or interactive systems. Let’s create a simple conversational agent that refines a blog post outline based on feedback:

import os
from openclaw import OpenClaw

client = OpenClaw()

def refine_blog_outline(initial_topic: str):
    """
    Simulates a multi-turn conversation to refine a blog post outline.
    """
    messages = [
        {"role": "user", "content": f"Generate a detailed outline for a blog post about '{initial_topic}'."}
    ]

    print(f"--- Generating initial outline for '{initial_topic}' ---")
    response = client.chat.completions.create(
        model="claude-haiku-4-5",
        messages=messages,
        max_tokens=500
    )
    initial_outline = response.choices[0].message.content
    print(initial_outline)
    messages.append({"role": "assistant", "content": initial_outline})

    feedback = input("\nEnter your feedback on the outline (or 'quit' to finish): ")
    while feedback.lower() != 'quit':
        messages.append({"role": "user", "content": f"Based on this feedback: '{feedback}', please refine the outline."})
        print("\n--- Refining outline based on feedback ---")
        response = client.chat.completions.create(
            model="claude-haiku-4-5",
            messages=messages,
            max_tokens=500
        )
        refined_outline = response.choices[0].message.content
        print(refined_outline)
        messages.append({"role": "assistant", "content": refined_outline})
        feedback = input("\nEnter more feedback (or 'quit' to finish): ")

    print("\n--- Final Outline ---")
    # Join messages to show the full conversation or extract the last assistant message
    print(messages[-1]['content'])

if __name__ == "__main__":
    refine_blog_outline("The Future of Serverless Computing")

This script demonstrates how to maintain a conversation history by appending both user and assistant messages to the messages list. Each subsequent call to client.chat.completions.create then sends the entire history, allowing the model to maintain context. This is crucial for interactive agents or chained tasks where the output of one step informs the next. The limitation here is that this interactive script isn’t suitable for direct cron automation due to the input() calls. You would need to replace the interactive feedback loop with pre-defined rules or external data sources for full automation.

Limitations and Resource Considerations

While OpenClaw’s SDK is

Frequently Asked Questions

If you’re running OpenClaw for tasks like log analysis, code review, or customer support summarization, one of the most critical decisions you’ll face is selecting the right Large Language Model (LLM). The “best” model isn’t always the biggest or most expensive; it’s the one that delivers acceptable quality at a sustainable cost for your specific use case. Overlooking this can lead to exorbitant API bills or frustrated users waiting on slow, overly complex models.

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 OpenClaw’s LLM Integration

OpenClaw is designed to be model-agnostic, but its internal queuing and tokenization mechanisms are optimized for typical transformer-based models. When you configure an LLM in OpenClaw, you’re essentially telling it which API endpoint to hit and how to structure the request body. This is crucial because different providers have different rate limits, token limits, and pricing structures. For instance, an OpenAI model will expect a messages array, while a Cohere model might expect a prompt string. OpenClaw handles this abstraction, but the underlying characteristics of the model still dictate performance and cost.

Most of OpenClaw’s configuration for LLMs lives in ~/.openclaw/config.json under the "llm_providers" section. Here’s a typical snippet:

{
  "llm_providers": {
    "openai": {
      "type": "openai",
      "api_key_env": "OPENAI_API_KEY",
      "default_model": "gpt-4o",
      "models": {
        "gpt-4o": {
          "cost_per_input_token": 0.000005,
          "cost_per_output_token": 0.000015,
          "max_tokens": 128000
        },
        "gpt-3.5-turbo": {
          "cost_per_input_token": 0.0000005,
          "cost_per_output_token": 0.0000015,
          "max_tokens": 16385
        }
      }
    },
    "anthropic": {
      "type": "anthropic",
      "api_key_env": "ANTHROPIC_API_KEY",
      "default_model": "claude-3-opus-20240229",
      "models": {
        "claude-3-opus-20240229": {
          "cost_per_input_token": 0.000015,
          "cost_per_output_token": 0.000075,
          "max_tokens": 200000
        },
        "claude-3-haiku-20240307": {
          "cost_per_input_token": 0.00000025,
          "cost_per_output_token": 0.00000125,
          "max_tokens": 200000
        }
      }
    }
  }
}

Notice the cost_per_input_token and cost_per_output_token. These are vital for OpenClaw’s internal cost tracking and for making informed decisions. Keep these updated as providers change their pricing.

The Non-Obvious Truth: Cheaper Models are Often Good Enough

The biggest trap many OpenClaw users fall into is defaulting to the largest, most “intelligent” model available. For instance, the docs might implicitly suggest using gpt-4o or claude-3-opus for complex reasoning tasks. While these models are undoubtedly powerful, they come with a significant cost premium and often higher latency.

Here’s the insight: for 90% of practical OpenClaw use cases—summarizing short texts, extracting structured data from logs, generating simple code snippets, or classifying support tickets—models like Anthropic’s claude-3-haiku-20240307 or OpenAI’s gpt-3.5-turbo are more than sufficient. I’ve found claude-3-haiku-20240307 to be particularly impressive in its cost-to-performance ratio for general text processing. It’s often 10x cheaper than its larger siblings and nearly as fast, making it ideal for high-volume, lower-stakes tasks. The quality difference, especially after proper prompt engineering, is often negligible for these specific applications.

Consider a scenario where OpenClaw is processing hundreds of log entries per minute, identifying critical errors. Using gpt-4o for each entry would quickly deplete your budget. Switching to gpt-3.5-turbo or claude-3-haiku-20240307, with a well-crafted system prompt like “You are an expert at identifying critical errors in application logs. Respond only with ‘CRITICAL’ if a critical error is detected, otherwise respond ‘OK’.”, dramatically reduces costs without sacrificing accuracy in this specific context.

When to Opt for Larger Models

There are, of course, scenarios where the more capable, and expensive, models are indispensable. These typically involve tasks requiring deep reasoning, complex code generation, multi-step problem solving, or highly nuanced natural language understanding. For example:

• Advanced Code Refactoring: If OpenClaw is assisting with refactoring large codebases or proposing architectural changes, a model like gpt-4o or claude-3-opus will provide higher quality and more robust suggestions.
• Legal Document Analysis: Extracting specific clauses, identifying contradictions, or summarizing lengthy legal texts often benefits from the enhanced comprehension of top-tier models.
• Creative Content Generation: For generating marketing copy, story outlines, or complex scripts, the superior creativity and coherence of larger models can be worth the extra cost.
• Complex Troubleshooting: Analyzing system dumps, correlating multiple data sources, and proposing solutions to obscure technical issues can leverage the deeper reasoning capabilities.

In these cases, the cost increase is often justified by the higher quality output, reduced need for human intervention, or the complexity of the task itself, which simpler models might fail at entirely.

Limitations and Resource Considerations

While OpenClaw is efficient, the choice of LLM does have implications for your local system resources, especially if you’re doing any local embedding or pre-processing. However, for remote API calls, the primary limitation will be your budget and the API provider’s rate limits, not your local RAM or CPU.

This advice primarily applies when you’re using external LLM APIs. If you’re attempting to run local, open-source models (e.g., Llama 3 via Ollama) through OpenClaw, then hardware limitations become very real. Running a 7B parameter model locally typically requires at least 8GB of RAM, with 16GB being more comfortable for larger context windows. For 70B models, you’re looking at 64GB+ RAM or dedicated GPUs. A typical Hetzner VPS with 2GB RAM will struggle immensely with even a small local model. For API-based interactions, though, your VPS only needs enough resources to run OpenClaw itself, not the LLM.

It’s also important to factor in the total context window. If your OpenClaw tasks involve very long inputs (e.g., analyzing entire code repositories or lengthy transcripts), you’ll need models with large context windows. While many cheaper models now offer large contexts (e.g., Haiku’s 200k tokens), ensure their quality at the extremities of that window is acceptable for your specific task.

To optimize your OpenClaw setup and reduce API costs, review your common use cases. For any task that doesn’t demand the absolute pinnacle of reasoning or creativity, consider stepping down to a more cost-effective model. The savings can be substantial.

To implement this, open your ~/.openclaw/config.json file and change the "default_model" for the Anthropic provider from "claude-3-opus-20240229" to "claude-3-haiku-20240307":

    "anthropic": {

      "type": "anthropic",

      "api_key_env": "ANTHROPIC_API_KEY",

      "default_model": "claude-3-haiku-20240307",

      "models": {

        "claude-3-opus-2024022

Want to script OpenClaw with Python? See how to use the OpenClaw Python SDK for task automation →