OpenClaw Automation Recipes: Ready-to-Use Workflow Templates

OpenClaw's own adoption data tells a clear story: users who set up two or more automations in their first week stay active at a 78% rate three months later, compared to 41% for those who stop at one. The gap exists because the first workflow teaches the mental model (trigger, steps, output), and the second proves it generalizes. After that, adding a third or fourth recipe is trivially fast.

The problem is that most guides explain concepts without giving you anything to paste. The official TaskFlow documentation covers execution modes, state management, and CLI commands, but stops short of end-to-end recipes. Community sources like ClawTank and KiloClaw publish recipe lists, but they describe what an automation does rather than how to wire it up. This guide bridges that gap with seven recipes you can adapt to your own tools and schedules.

Before diving in, it helps to understand the two systems that make these recipes work: TaskFlow for multi-step orchestration, and cron scheduling for recurring triggers. TaskFlow was introduced in OpenClaw 2026.4.2 as a durable orchestration layer with two execution modes, approval gates, and state that survives restarts. Cron scheduling handles the timing side, letting you attach any recipe to a repeating schedule with timezone support and session persistence.

Every recipe in this guide relies on three TaskFlow primitives. Understanding them once means you can modify any recipe or build your own.

Managed vs. Mirrored Execution

Managed mode means TaskFlow controls the full lifecycle of each step: it creates tasks, drives them to completion, and advances the flow state automatically. This is the default for recipes where OpenClaw owns the entire workflow. Mirrored mode observes externally-created tasks without taking ownership, which is useful when OpenClaw needs to track progress from cron jobs, CI pipelines, or other orchestration systems running outside the agent.

Approval Gates

Any step in a TaskFlow can require human approval before proceeding. You mark a step as requiring approval in the workflow definition, and the flow pauses until a human reviews the output and confirms. If the reviewer denies the step, the downstream steps that depend on that approval are skipped automatically. This is how recipes that send emails, publish reports, or modify production systems stay safe: nothing goes out without a human in the loop.

Cron Scheduling with Session Context

OpenClaw's cron system lets you attach any recipe to a repeating trigger using standard cron expressions with timezone support. The key decision is the session type. A persistent session gives the agent context across runs, so it remembers which emails, PRs, or events it already processed. An isolated session starts each run with a clean slate, which is better for independent tasks like generating a fresh report from scratch. You configure both the schedule and the session type when you register the recipe with the cron system.

Preflight Checks

Before any recipe executes, TaskFlow can validate prerequisites: API credential availability, network reachability, required tool enablement, and failure destination configuration. Including a preflight step catches misconfiguration before the workflow burns through API calls or produces partial output.

This recipe aggregates calendar events, priority emails, weather, and top news stories into a single briefing delivered to Slack or Telegram each morning. It uses managed mode with an approval gate so you can review the briefing before it sends.

What it does:

1. Pulls today's calendar events via Google Calendar API
2. Scans unread emails and filters by sender priority list
3. Fetches local weather and headline news
4. Formats everything into a structured daily summary
5. Pauses for your approval before sending to the delivery channel

Schedule: Weekdays at 7:00 AM in your local timezone.

Session type: Use session:morning-brief so the agent remembers your sender priority list and formatting preferences across runs.

Approval gate: The briefing preview step uses approval: required. You get a formatted preview in your chosen channel. Reply to confirm, and the agent delivers the final version. This prevents hallucinated calendar entries or misread email subjects from reaching your team.

Adaptation tips: Remove the news aggregation step if you prefer a work-only briefing. Add a step that checks your project management tool (Linear, Jira, Asana) for tasks due today. The format step can output markdown, HTML, or plain text depending on your delivery channel.

Persistent storage for your OpenClaw automation outputs

Every recipe generates files: triage reports, daily briefings, weekly summaries. Fastio gives your agents 50GB of indexed, searchable storage with file locking and MCP access. No credit card, no trial expiration.

Start 14-Day Trial

CI failures that sit unnoticed for hours slow down entire teams. This recipe monitors GitHub Actions (or any CI provider with automation hooks support), triages failures by category, and posts actionable summaries to your team channel.

What it does:

1. Preflight check verifies GitHub token permissions and Slack automation hooks URL
2. Polls recent workflow runs for failures (or listens via automation hooks in mirrored mode)
3. Reads failure logs and categorizes the issue: flaky test, dependency problem, config drift, or genuine code regression
4. Posts a triage summary with the failure category, relevant log lines, and a suggested first action
5. Tags the last committer on the failing branch

Schedule: Every 15 minutes during business hours, or event-driven via automation hooks.

Session type: Use a persistent session so the agent tracks which failures it already reported and avoids duplicate alerts across runs.

Choosing the right execution mode: If your CI system already manages job state and retries, mirrored mode lets OpenClaw observe and enrich alerts without duplicating that logic. If you want the agent to own the full lifecycle, including automatic flaky-test retries, managed mode is the better fit.

Why this adds value over stock CI notifications: A raw failure notification tells you something broke. This recipe adds a triage layer that reads the logs, categorizes the failure type, and suggests a first response action. That reduces the cognitive load on whoever picks up the alert.

Where this recipe generates files (triage reports, log extracts, trend analysis), you need shared storage. Local filesystems work for solo developers but create conflicts when multiple agents write concurrently. Fastio workspaces provide persistent storage with file locking, so parallel CI monitors do not overwrite each other. The free tier includes 50GB and included credits with no credit card required.

About 48% of OpenClaw users deploy the platform for productivity automation, and email triage is the single most requested recipe category. This workflow scans your inbox on a schedule, categorizes messages by urgency, drafts replies for routine items, and queues high-priority threads for your attention.

What it does:

1. Connects to Gmail (or any IMAP-compatible provider)
2. Scans unread messages since the last run
3. Categorizes each message: urgent (needs reply today), routine (can draft a response), informational (archive), or spam
4. Drafts reply templates for routine messages
5. Posts a summary of urgent items to your preferred channel
6. Archives informational messages automatically

Schedule: Every 30 minutes during work hours, using a persistent session so the agent remembers which messages it already processed.

Approval gate: Add approval: required before the auto-archive and auto-reply steps. This lets you review what gets archived and what replies get sent in your name. Once you trust the categorization accuracy (usually after a week of corrections), you can remove the gate for routine categories while keeping it for replies.

Handling attachments: When the triage assistant encounters messages with attachments that need team review, those files need to go somewhere accessible. S3 buckets work if your team already uses AWS. Google Drive is fine for small teams. For agent-to-human handoff scenarios where you want the recipient to get a branded portal link instead of a raw file dump, Fastio's share functionality creates trackable delivery links with audit trails. The agent uploads the attachment, generates a share link, and includes it in the triage summary.

The remaining four recipes target developer-specific automation. Each follows the same TaskFlow structure: preflight, collect, process, approve (optional), deliver.

PR Review Reminder

Stale pull requests slow down shipping velocity. This recipe checks your GitHub organization for PRs that have been open longer than a configurable threshold (default: 48 hours) without review activity, then pings the assigned reviewer directly.

• Schedule: Twice daily, 10:00 AM and 3:00 PM
• Session: isolated (each run is independent)
• Key detail: The recipe excludes draft PRs and PRs with the "do not review" label. It escalates to the team lead if a PR passes 72 hours with no review

Dependency Update Digest

Outdated dependencies create security risk and maintenance debt. This recipe scans your repositories weekly, identifies packages with available updates, groups them by severity (security patch, minor, major), and posts a prioritized update plan.

• Schedule: Monday mornings at 9:00 AM
• Session: session:deps-digest to track which updates you have already acknowledged
• Key detail: Security patches get flagged with urgency. Major version bumps include a link to the changelog and breaking changes summary

End-of-Day Summary

This recipe captures what happened during the workday: commits pushed, PRs merged, emails sent, meetings attended, and tasks completed. It formats everything into a concise daily log.

• Schedule: Weekdays at 5:30 PM
• Session: session:eod-summary to accumulate context throughout the day
• Key detail: The summary includes a "tomorrow's priorities" section based on calendar events and approaching deadlines

Weekly Report Generator Compiles the week's end-of-day summaries into a team-facing weekly report with metrics: PRs merged, issues closed, deployment count, and incident summary. Includes an approval gate before distribution.

• Schedule: Friday at 4:00 PM
• Session: session:weekly-report
• Approval gate: Required before sending, so you can edit the narrative summary before your team or manager sees it
• Key detail: The report pulls from the end-of-day session history, so it works best when both recipes run on the same OpenClaw instance

File storage for generated reports: Weekly reports, dependency digests, and triage logs accumulate quickly. For teams running multiple agents, you need shared storage that supports concurrent writes without conflicts. Fastio workspaces handle this with file locking and versioning, and the MCP server lets agents read and write files programmatically. Agents upload reports, humans review them through the web UI or a branded share link, and the audit trail tracks every version.

These seven recipes cover common patterns, but the real value of TaskFlow is composability. Here is how to adapt them.

Swap delivery channels. Every recipe assumes a specific output channel (Slack, Telegram, email), but the delivery step is independent from the collection and processing steps. Replace the final step's channel configuration to deliver via whatever your team uses.

Chain recipes into pipelines. The CI failure triage recipe can feed into the end-of-day summary. The email triage assistant's urgent queue can populate tomorrow's priorities in the morning briefing. TaskFlow's session persistence means one recipe's output becomes another recipe's input when they share a session namespace.

Add mirrored mode for existing systems. If you already have a Jenkins pipeline, Datadog monitor, or PagerDuty escalation policy, use mirrored mode to observe those systems without duplicating their logic. OpenClaw tracks the external task state and adds its own processing layer on top.

Scale with preflight checks. As your recipe count grows, preflight checks become essential. A recipe that requires five API credentials should verify all five before executing the first step. This prevents partial runs that leave state in an inconsistent position.

Persist outputs for team access. Single-developer setups can store recipe outputs locally. Teams need shared, persistent storage. Local filesystems do not support concurrent agent writes. Cloud storage like S3 requires IAM configuration and does not provide built-in search or handoff. Fastio intelligent workspaces index uploaded files automatically, so your team can search recipe outputs by meaning, not just filename. The Business Trial includes 50GB storage, included credits, and five workspaces with no credit card or trial expiration.