This is a submission for the OpenClaw Writing Challenge

What I Built

After chatting with a few OpenClaw experts, I learned that most people use OpenClaw primarily for OPC.

That made me realize that this project could be used as a general platform for building AI staffs, not just for that single use case.

So I spun up OpenClaw on an Azure VM and started building.

I built a beta version of an automated daily campaign-letter summarizer on Azure using OpenClaw. Every morning at 9am, my agent scans a folder of campaign letters, summarizes them, and writes a clean daily report.

The most interesting part?

I didn't write any .claw files, YAML, or Python glue code manually.

Instead, I discovered that OpenClaw can create skills and cron tasks directly through conversation, which turned out to be the most reliable way to build automation.

I chose the cloud for the PoC because it avoids running this on my personal computer. After the trial, I can shut down and delete the Azure resources, minimizing ongoing costs and reducing exposure of my data and environment.

This project became my first step toward a "one-person AI company", a system that runs tasks for me automatically, every day.

How I Used OpenClaw

1. Setting Up the Azure VM

I deployed an Ubuntu VM on Azure to host OpenClaw. This gave me a stable, always-on environment for scheduled tasks.

2. Installing WSL + Ubuntu

Inside the VM, I used WSL to create a clean Ubuntu environment. This kept OpenClaw isolated and easy to reset.

wsl --install

3. Installing OpenClaw

I installed OpenClaw using the official script:

curl "fsSL https://get.openclaw.ai/install.sh | bash

Then launched the TUI:

openclaw tui

This dropped me into the interactive agent environment.

(This is a security reminder. You're worth taking the time to read it.)

4. Upgrading Ollama to Cloud Pro

A free Ollama API key caused authentication and provider errors. Switching to Ollama Cloud Pro solved everything instantly.
(so, I paid for a month for this PoC, which was $20 USD (˵ ͡° ͜ʖ ͡°˵))

My agent now runs on:

ollama/kimi-k2.5:cloud

Then in TUI:

/model ollama/kimi-k2.5:cloud

5. Creating the Skill (Just by Asking)

At first, I tried to follow the docs and create skills manually by writing Python files and placing them under:

~/.openclaw/workspaces/main/skills/

Those never loaded properly in my environment.

The real breakthrough came when I stopped fighting the filesystem and simply asked the agent in chat:

"Create the skill that summarizes campaign letters from a folder."

and showed him the example:

from claw import skill
import os

@skill
def summarize_campaign_letters(folder: str = "~/openclaw/campaign_letters"):
    folder = os.path.expanduser(folder)
    summaries = []

    for filename in os.listdir(folder):
        path = os.path.join(folder, filename)
        if not os.path.isfile(path):
            continue

        with open(path, "r", encoding="utf-8") as f:
            content = f.read()

        summary = skill.llm(
            f"Summarize the following campaign letter in 5 bullet points:\n\n{content}"
        )

        summaries.append(f"## {filename}\n{summary}\n")

    if not summaries:
        return "No campaign letters found."

    return "\n".join(summaries)

Then OpenClaw generated the skill, and the /skill command just worked:

/skill summarize_campaign_letters "~/openclaw/campaign_letters"

Under the hood, the Python script that actually runs lives at:

~/.npm-global/lib/node_modules/openclaw/skills/summarize-campaign-letters/scripts/summarize.py

6. Creating the Daily Automation (Cron via Chat)

My agent didn't have a /schedule command, so OpenClaw offered to create a cron job instead.

I simply chatted:

Yes, create one.
Daily summary at 9am
run /skill summarize_campaign_letters

OpenClaw generated the cron entry automatically.

Reminder: Gateway is running but in read-only mode. The cron job needs write capability to create jobs.

Now every morning at 9am (HKT), the agent runs:

/skill summarize_campaign_letters

and writes the output into my reports folder.

Demo

Here's how the system behaves:

• I place text files into the ~/openclaw/campaign_letters folder.
• At 9am, the cron job runs.
• OpenClaw summarizes each letter.
• A new campaign-summary.md appears in my reports folder.

This can easily be extended to:

• Email delivery
• WhatsApp notifications
• PDF OCR
• Multi-step workflows

But even the basic version already saves me time every morning.

What I Learned

1. Chat-Driven Creation Beats Manual Files

I tried to manually place Python skills under ~/.openclaw/workspaces/main/skills/ and reload them. But the path and startup/loading behavior made it fragile.

When I simply described what I wanted in natural language, and let OpenClaw use its own skill-creation flow, it was:

• Faster
• Self‑correcting (the agent asks clarifying questions and fixes its own mistakes)
• Far more adaptive to rapid changes

2. Cron Is the Real Scheduler in My Setup

In my setup, the agent didn’t have a /schedule command. But it could:

• Inspect existing cron jobs
• Propose new ones
• Write/update them for me

So instead of fighting for a missing command, I let the agent set up cron directly.

3. You Can Build Automation, But Treat AI Output as Untrusted

OpenClaw can create skills for you, and that's powerful, but it also means the system is "close to" something that can hallucinate.

If the AI generates the wrong skill code, wrong paths, or an unsafe workflow, your automation could run the wrong actions automatically (every day), which is exactly the kind of failure that's easy to miss.

So the key lesson is: use AI for building, but verify before trusting.

For example:

• Review the created skills/tasks before enabling the automation
• Start with a small test dataset and a short run window
• Add guardrails (e.g., permissions, allowed folders, simple sanity checks on outputs)
• Keep the blast radius small-especially in the first PoC run

That's how you get the speed of AI-driven setup without letting hallucinations silently turn into risk.

Just remember:

ClawCon Michigan

I didn't attend ClawCon Michigan, but I followed the event online and enjoyed seeing how others used OpenClaw creatively. This challenge pushed me to build something practical and automated, and I'm glad I did.

Love AI!