OpenClaw Cron Setup: How to Create Reminders and Scheduled Workflows

If you want OpenClaw to do something at a specific time, use cron. The practical rule is simple: heartbeat is for periodic awareness, cron is for scheduled certainty. If you need a reminder at 4 PM, a job every Monday morning, or a recurring workflow that should run on a schedule, cron is the tool to reach for.

That distinction matters because a lot of people mix the two together. They try to use heartbeat for exact reminders, or they use cron for tasks that really need judgment and context. The result is either missed timing or clunky workflows.

This tutorial walks through how to set up cron jobs in OpenClaw, which schedule types to use, how to choose the right payload, and how to write reminders that actually read well when they fire.

If you want the basics of the platform first, start with what OpenClaw is and workspace files. If you are also designing proactive checks, pair this guide with OpenClaw heartbeat setup.

What cron is doing in OpenClaw

Cron gives OpenClaw a schedule.

That schedule can be:

• a one-time reminder at a specific timestamp
• a repeating interval
• a recurring calendar expression such as every morning or every Monday

The point is timing.

Cron is the right fit when the question is not "should the agent check?" but rather "when should this happen?"

When to use cron instead of heartbeat

Use cron when:

• exact timing matters
• the task must fire even if nothing else is happening
• you are setting a reminder
• you need a recurring workflow on a fixed schedule
• the schedule itself is the core requirement

Use heartbeat when:

• the agent should periodically look for important changes
• the task can drift a little
• recent conversational context matters
• it is fine for the agent to do nothing if nothing changed

That one distinction saves a lot of confusion.

Step 1: choose the schedule type

OpenClaw supports three useful scheduling patterns.

One-time schedule

Use this when you want a reminder once at a specific time.

Examples:

• remind me in 20 minutes to call a client
• remind me tomorrow morning to review a draft
• fire a follow-up at a fixed timestamp

Every interval

Use this when you want something on a simple repeating interval.

Examples:

• every 6 hours
• every 24 hours
• every 15 minutes

Cron expression

Use this when the job should follow a calendar pattern.

Examples:

• every weekday at 8 AM
• every Monday at 9 AM
• every month on the first business day

A simple rule of thumb:

• one-time for single reminders
• every for raw intervals
• cron expressions for calendar-based schedules

Step 2: decide whether the job is a reminder or an agent run

This is the next big choice.

In OpenClaw, cron jobs can carry different payload types depending on what should happen when the schedule triggers.

The two most important patterns are:

• a reminder-style system event
• an agent turn that runs a real workflow

A reminder is basically a timed message.

An agent turn is more like saying, "At this time, go do the work."

That difference matters. A reminder should read well as a message. An agent run should be written like an instruction.

Step 3: write good reminder text

Most reminder mistakes are copy mistakes.

A good reminder should sound like something you would actually want to receive.

Bad reminder text:

• Task due.
• Reminder triggered.
• Check prior context.

Better reminder text:

• Reminder: review the client proposal before your 2 PM meeting.
• Reminder: send the follow-up to Sarah if you still have not heard back.
• Reminder: this is your Friday check to review open leads before the weekend.

The message should make sense when it arrives cold.

Step 4: create a one-time reminder

A one-time reminder is the simplest cron job.

The structure usually includes:

• a schedule with kind: at
• a timestamp
• a payload that contains the reminder text

A simple example looks like this:

{
  "schedule": {
    "kind": "at",
    "at": "2026-04-05T16:00:00Z"
  },
  "payload": {
    "kind": "systemEvent",
    "text": "Reminder: call the client before the pricing window closes today."
  }
}

The important part is not memorizing the JSON. It is choosing the right message and the right time.

Step 5: create a recurring daily or weekly job

If the task repeats on a predictable cadence, use a recurring schedule.

For example, a weekday morning briefing could look like this:

{
  "schedule": {
    "kind": "cron",
    "expr": "0 8 * * 1-5",
    "tz": "America/Chicago"
  },
  "payload": {
    "kind": "agentTurn",
    "message": "Prepare the daily work summary: urgent items, upcoming meetings, and open follow-ups that need attention today."
  }
}

This is a good example of an agent turn because the job is not just a message. It is a scheduled workflow.

Step 6: decide where the result should go

A scheduled job is only useful if the output lands in the right place.

Ask:

• should this come back as a message?
• should it run quietly unless there is something important?
• should it announce completion?
• should it go to a specific channel or session?

These choices matter more than people think. A well-timed reminder in the wrong place is still a miss.

Step 7: test the smallest version first

Do not start with a huge recurring workflow.

Start with one simple job, confirm that it fires when expected, and confirm that the output reads the way you want.

Then expand.

This is especially important for recurring jobs. A slightly wrong daily job becomes a daily annoyance.

Good cron examples for OpenClaw

Here are three solid starting patterns.

One-time reminder

• remind me in 20 minutes to send the quote

Daily review prompt

• every weekday at 8 AM, prepare today's priorities and urgent follow-ups

Weekly cleanup workflow

• every Friday afternoon, review stale tasks, pending leads, and unresolved action items

All three are clear, time-based, and easy to evaluate.

Common cron mistakes

Mistake 1: using cron when heartbeat would be better

If the real task is "check whether anything matters," heartbeat is the better fit.

Mistake 2: vague reminder copy

A reminder should stand on its own. If the text is too generic, it becomes background noise.

Mistake 3: wrong timezone assumptions

Always be explicit about timezone when it matters.

Mistake 4: starting with a complicated recurring workflow

You do not need a fully automated morning operations system on day one. Start with one useful job.

How cron and heartbeat work together

In a solid OpenClaw setup, heartbeat and cron are partners.

Heartbeat gives you periodic awareness.

Cron gives you exact timing.

A practical example:

• heartbeat checks for urgent issues through the day
• cron sends the precise 4 PM reminder that must not drift

Used together, they cover most proactive workflow needs.

My recommendation

If you are new to cron in OpenClaw, start with two jobs only:

• one one-time reminder
• one recurring daily or weekly workflow

That is enough to learn the shape of the system without cluttering it.

Write reminder messages like a human would want to read them. Keep scheduled agent turns tightly scoped. And do not use cron as a substitute for better workflow design.

If you want the official references, review the OpenClaw docs and the OpenClaw GitHub repository. Then compare every new cron job against one simple question: does timing itself matter here, or am I really trying to solve a different problem?

FAQ

What is cron in OpenClaw?

Cron is the scheduling layer that lets you run reminders and workflows at specific times, intervals, or recurring calendar patterns.

When should I use cron instead of heartbeat?

Use cron when exact timing matters. Use heartbeat when the task is a periodic check that may or may not need to report anything.

What is the difference between a reminder and an agent turn?

A reminder is a timed message. An agent turn is a scheduled instruction that asks the agent to perform work.

What is the best first cron job to create?

A one-time reminder or a daily review workflow are both strong first jobs because they are easy to test and clearly useful.

How do I keep cron jobs from becoming annoying?

Use clear timing, good reminder text, the right timezone, and tight scope. Start small and only add recurring jobs that prove their value.

One more habit that helps: name jobs clearly

A small detail, but it matters. Give cron jobs names that explain what they do without forcing you to inspect the payload every time.

Good names:

• Daily briefing for ops
• Friday stale lead review
• Reminder to send client follow-up

Bad names:

• job 1
• reminder
• automation task

When a schedule misfires, duplicates, or needs to be updated later, a clear job name saves time immediately. It also makes the whole setup easier to audit when you return to it a month later.