5 OpenClaw Automations That Actually Save You Hours

5 Automations That Actually Save You Hours

OpenClaw isn’t just a chatbot you message when you need something. The real value comes when it works for you — checking your inbox, watching your calendar, summarizing overnight updates, and nudging you before things slip.

This guide covers five automations you can set up in under 30 minutes. Each one is battle-tested and uses real OpenClaw features.

Understanding Heartbeats vs Cron

Before diving in, you need to understand the two scheduling mechanisms:

Heartbeat = periodic check-in (default every 30 min). Runs in your main session with full context. Best for batching multiple checks together.

Cron = precise scheduler. Can run at exact times, in isolated sessions, with different models. Best for standalone tasks and one-shot reminders.

Use case	Best fit	Why
Check inbox every 30 min	Heartbeat	Batches with other checks
Daily report at 9am sharp	Cron (isolated)	Exact timing needed
”Remind me in 20 min”	Cron (one-shot)	Precise, single-use
Monitor calendar	Heartbeat	Context-aware, natural fit
Weekly deep analysis	Cron (isolated)	Different model, standalone

Rule of thumb: If it can batch with other checks and timing doesn’t need to be exact → heartbeat. If it needs a specific time or isolation → cron.

Automation 1: The Morning Briefing

What it does: Every morning at 7am, your agent generates a summary of weather, calendar events, top emails, and anything you missed overnight. Delivered to your phone.

Setup

openclaw cron add \
  --name "Morning briefing" \
  --cron "0 7 * * *" \
  --tz "Europe/Berlin" \
  --session isolated \
  --message "Generate today's morning briefing: weather forecast, calendar events for today and tomorrow, top unread emails, any pending tasks from yesterday. Keep it scannable — bullet points, not paragraphs." \
  --announce \
  --channel telegram \
  --to "YOUR_CHAT_ID"

Replace YOUR_CHAT_ID with your Telegram chat ID and Europe/Berlin with your timezone.

What’s happening under the hood

--session isolated: Runs in a clean session (cron:<jobId>), doesn’t clutter your main chat history.
--announce: Delivers the result directly to your Telegram/WhatsApp.
The agent starts fresh each run — no context from previous days (which is what you want for a daily summary).

Pro tips

Use --model opus for higher-quality summaries, or a cheaper model like sonnet for faster/cheaper runs.
Set --thinking high for the weekly review version.
Add --channel whatsapp --to "+15551234567" to deliver via WhatsApp instead.

Automation 2: Smart Heartbeat Monitoring

What it does: Every 30 minutes, your agent checks inbox, calendar, and pending tasks — and only pings you when something actually matters.

Setup

Step 1: Configure the heartbeat (in ~/.openclaw/openclaw.json):

{
  agents: {
    defaults: {
      heartbeat: {
        every: "30m",
        target: "last",           // deliver to whatever channel you last used
        activeHours: {
          start: "08:00",
          end: "22:00",           // no pings between 10pm and 8am
        },
      },
    },
  },
}

Step 2: Create HEARTBEAT.md in your workspace (~/.openclaw/workspace/HEARTBEAT.md):

# Heartbeat checklist

- Check email for urgent messages (flagged, from known VIPs)
- Review calendar for events in the next 2 hours
- If a background task or sub-agent finished, summarize results
- If idle for 8+ hours during daytime, send a brief check-in
- Track check state in memory/heartbeat-state.json

Why heartbeat instead of multiple cron jobs?

One heartbeat replaces 4+ cron jobs (email check, calendar check, task check, idle check). It runs in your main session so it has full context — it knows what you’ve been working on and can prioritize accordingly.

The HEARTBEAT_OK response contract is key: if nothing needs attention, the agent replies HEARTBEAT_OK and no message is delivered. You only get pinged when something matters.

Tracking state

Your agent can track what it’s already checked in memory/heartbeat-state.json:

{
  "lastChecks": {
    "email": 1703275200,
    "calendar": 1703260800,
    "weather": null
  }
}

This prevents the agent from re-reporting the same email or event on every heartbeat cycle.

Automation 3: Gmail Push Notifications

What it does: When a new email arrives, OpenClaw gets notified instantly (not on a polling interval) and summarizes it. Critical emails get forwarded to your phone immediately.

This uses Gmail Pub/Sub — Google pushes new email events to your OpenClaw instance in real-time.

Prerequisites

gcloud CLI installed and logged in
gog (gogcli) installed and authorized for Gmail
Tailscale installed and logged in (for the public push endpoint)

Setup (the easy way)

openclaw webhooks gmail setup --account your@gmail.com

This wizard handles everything: Pub/Sub topic creation, permissions, Tailscale funnel, and OpenClaw hook config.

Setup (manual)

Step 1: Enable APIs

gcloud services enable gmail.googleapis.com pubsub.googleapis.com

Step 2: Create Pub/Sub topic

gcloud pubsub topics create gog-gmail-watch
gcloud pubsub topics add-iam-policy-binding gog-gmail-watch \
  --member=serviceAccount:gmail-api-push@system.gserviceaccount.com \
  --role=roles/pubsub.publisher

Step 3: Configure the hook (in openclaw.json):

{
  hooks: {
    enabled: true,
    token: "YOUR_HOOK_TOKEN",
    presets: ["gmail"],
    mappings: [
      {
        match: { path: "gmail" },
        action: "agent",
        wakeMode: "now",
        name: "Gmail",
        deliver: true,
        channel: "last",
        model: "openai/gpt-4o-mini",  // cheaper model for email triage
      },
    ],
  },
}

Step 4: Start the watcher

With hooks.enabled=true and hooks.gmail.account set, the Gateway auto-starts the watcher. Or run it manually:

openclaw webhooks gmail run

What you get

Instant email notifications (not polling)
AI-summarized emails with extracted action items
Configurable model (use a cheap model for email triage)
Delivery to your last-used channel or a specific channel

Cost tip

Set model: "openai/gpt-4o-mini" in the mapping. Email triage doesn’t need Opus.

Automation 4: One-Shot Reminders

What it does: Quick reminders that fire once and delete themselves. The simplest automation, but maybe the most useful.

Examples

# Remind in 20 minutes
openclaw cron add \
  --name "Meeting reminder" \
  --at "20m" \
  --session main \
  --system-event "Reminder: standup starts in 10 minutes" \
  --wake now \
  --delete-after-run

# Remind at a specific time
openclaw cron add \
  --name "Call back client" \
  --at "2026-03-15T16:00:00+01:00" \
  --session main \
  --system-event "Reminder: call back the client about the proposal" \
  --wake now \
  --delete-after-run

# Remind tomorrow morning
openclaw cron add \
  --name "Review PR" \
  --at "2026-03-16T09:00:00+01:00" \
  --session main \
  --system-event "Reminder: review and merge the auth refactor PR" \
  --wake now \
  --delete-after-run

How they work

--at "20m" or an ISO timestamp sets a one-shot schedule
--session main + --system-event enqueues it in your main session
--wake now triggers an immediate heartbeat when it fires
--delete-after-run cleans up the job after it runs

You can also just tell your agent in chat:

“Remind me to call the client in 2 hours”

And it will create the cron job for you.

Managing reminders

# List all scheduled jobs
openclaw cron list

# See run history
openclaw cron runs --id <job-id>

# Delete a job
openclaw cron remove <job-id>

Automation 5: Weekly Deep Review

What it does: Every Monday at 9am, your agent runs a thorough review of the past week using a powerful model, then delivers a structured summary.

Setup

openclaw cron add \
  --name "Weekly review" \
  --cron "0 9 * * 1" \
  --tz "Europe/Berlin" \
  --session isolated \
  --message "Weekly review time. Analyze: 1) What tasks were completed this week (check memory files). 2) What's still pending or blocked. 3) Key decisions made. 4) Suggestions for next week. Format as a structured report with clear sections." \
  --model opus \
  --thinking high \
  --announce \
  --channel telegram \
  --to "YOUR_CHAT_ID"

Why this works

Isolated session: Clean slate, no context pollution from daily chats.
Model override: Uses Opus for high-quality analysis, even if your daily model is Sonnet.
Thinking: --thinking high enables extended reasoning for better synthesis.
Announce: Delivers directly to Telegram, so you get the report without opening a dashboard.

Variations

Monthly review (first Monday of each month):

openclaw cron add \
  --name "Monthly review" \
  --cron "0 9 1 * *" \
  --tz "Europe/Berlin" \
  --session isolated \
  --message "Monthly review..." \
  --model opus \
  --thinking high \
  --announce \
  --channel telegram \
  --to "YOUR_CHAT_ID"

Daily end-of-day summary:

openclaw cron add \
  --name "EOD summary" \
  --cron "0 18 * * 1-5" \
  --tz "Europe/Berlin" \
  --session isolated \
  --message "Summarize today: what happened, what's pending for tomorrow, anything I might have missed." \
  --announce \
  --channel whatsapp \
  --to "+15551234567"

Putting It All Together

Here’s what a well-automated OpenClaw setup looks like:

HEARTBEAT.md

# Heartbeat checklist

- Scan inbox for urgent emails
- Check calendar for events in the next 2 hours
- Review any pending tasks or sub-agent results
- If quiet for 8+ hours during daytime, brief check-in

Cron jobs

# Morning briefing at 7am
openclaw cron add --name "Morning brief" --cron "0 7 * * *" --tz "Europe/Berlin" --session isolated --message "Morning briefing: weather, calendar, top emails" --announce --channel telegram --to "CHAT_ID"

# Weekly review Monday 9am
openclaw cron add --name "Weekly review" --cron "0 9 * * 1" --tz "Europe/Berlin" --session isolated --message "Weekly review..." --model opus --thinking high --announce --channel telegram --to "CHAT_ID"

Config (openclaw.json)

{
  agents: {
    defaults: {
      heartbeat: {
        every: "30m",
        target: "last",
        activeHours: { start: "08:00", end: "22:00" },
      },
    },
  },
  hooks: {
    enabled: true,
    presets: ["gmail"],
  },
}

The result

7:00 AM — Morning briefing delivered to your phone
8:00 AM – 10:00 PM — Heartbeat checks every 30 min (inbox, calendar, tasks)
Real-time — Gmail push notifications for new emails
Ad-hoc — One-shot reminders whenever you need them
Monday 9:00 AM — Weekly review with deep analysis

All of this runs on your machine, with your data, under your control. No SaaS subscription, no data leaving your network.

Cost Considerations

Automation	~Monthly cost (Sonnet)	~Monthly cost (Opus)
Heartbeat (30min, 14h/day)	~$15-25	~$60-100
Morning briefing (daily)	~$3-5	~$10-15
Weekly review	~$0.50	~$2
Gmail hooks (varies)	~$2-10	~$5-20

These are rough estimates. Actual costs depend on prompt length, tool usage, and response complexity.

Cost tips:

Keep HEARTBEAT.md small (fewer tokens per cycle)
Use target: "none" on heartbeat if you only want internal processing
Use cheaper models for routine tasks (email triage, reminders)
Use activeHours to avoid running heartbeats overnight

What’s Next?

Multi-Agent Routing — Different agent per channel
Crafting the Perfect SOUL.md — Give your agent real personality
Starter Kits — Pre-built configs to get started fast

Automation is the difference between an AI you chat with and an AI that works for you.