How to Create a Scheduled Skill in OpenClaw for Slack

What Is a Scheduled Skill in OpenClaw?

OpenClaw skills are the building blocks of your AI agent's capabilities. A scheduled skill is a skill that runs automatically on a defined interval or at a specific time — no human trigger required. Instead of waiting for someone to type a command in Slack, your agent wakes up, does the work, and posts results wherever they're needed.

This is one of the most powerful patterns in OpenClaw, and when deployed through SlackClaw, it transforms your Slack workspace into an active workspace assistant rather than a passive one. Your agent can pull a standup summary every morning, check for stale pull requests every hour, or ping a channel when a Linear ticket crosses a deadline threshold — all without anyone lifting a finger.

Before You Start: What You'll Need

Before writing your first scheduled skill, make sure the following are in place:

• A SlackClaw workspace with at least one agent configured on your dedicated server
• At least one OAuth integration connected (GitHub, Jira, Notion, Linear, Gmail — whatever your skill will touch)
• Basic familiarity with OpenClaw's skill schema (YAML or JSON, depending on your setup)
• A Slack channel where the agent has posting permissions

SlackClaw's one-click OAuth means connecting tools like GitHub or Notion takes about thirty seconds. If you haven't connected the tools your skill will need, do that first from the integrations panel before writing any code.

Anatomy of an OpenClaw Scheduled Skill

Every OpenClaw skill is defined by a skill manifest. For a scheduled skill, there are a few additional fields beyond a standard skill definition. Here's the core structure:

skill:
  name: daily-standup-digest
  description: Pulls open PRs, active Linear tickets, and Notion updates each morning and posts a digest to #engineering.
  type: scheduled
  schedule:
    cron: "0 9 * * 1-5"
    timezone: "America/New_York"
  tools:
    - github.list_pull_requests
    - linear.list_issues
    - notion.query_database
    - slack.post_message
  memory: true
  output:
    channel: "#engineering"
    format: digest

Let's break down the key fields you need to get right.

The schedule Block

The cron field accepts standard five-part cron syntax. 0 9 * * 1-5 means "9:00 AM, Monday through Friday." The timezone field is important — OpenClaw runs on UTC internally, but SlackClaw translates this for your team's local timezone so your 9 AM digest actually arrives at 9 AM, not 2 PM.

Common schedule patterns:

• "0 9 * * 1-5" — Weekday mornings at 9 AM
• "0 */4 * * *" — Every four hours
• "30 17 * * 5" — Friday at 5:30 PM (end-of-week wrap-up)
• "0 0 1 * *" — First of every month at midnight

The tools Block

This is where OpenClaw knows which integrations to invoke. Tool names follow the pattern integration.method. Because SlackClaw connects to 800+ tools via OAuth, you have an enormous surface area here. For a standup digest, you might pull from GitHub, Linear, and Notion simultaneously. For a billing alert, you might query Stripe and post to a finance channel. The agent orchestrates these calls in the right order, handles pagination, and synthesizes the results.

The memory Flag

Setting memory: true tells the agent to use SlackClaw's persistent memory layer when executing this skill. This is significant. With memory enabled, the agent can remember what it reported yesterday and only surface what's actually new today. It won't re-surface the same stale PR it mentioned on Monday. It can track trends — "this is the third week this ticket has been mentioned without progress" — and include that context in its output. Learn more about our pricing page.

Without persistent memory, every scheduled run is stateless. With it, your agent builds up context over time and becomes genuinely more useful the longer it runs. Learn more about our integrations directory.

Step-by-Step: Building a PR Staleness Checker

Let's walk through a concrete, practical example: a skill that checks for pull requests open longer than three days and posts a nudge to your engineering channel every weekday at 10 AM.

Step 1: Define the Skill Manifest

skill:
  name: stale-pr-checker
  description: Identifies pull requests open for more than 3 days and notifies the engineering channel.
  type: scheduled
  schedule:
    cron: "0 10 * * 1-5"
    timezone: "America/Chicago"
  tools:
    - github.list_pull_requests
    - slack.post_message
  memory: true
  parameters:
    stale_threshold_days: 3
    repositories:
      - "my-org/frontend"
      - "my-org/backend-api"
  output:
    channel: "#engineering"
    format: list
    include_assignees: true

Step 2: Add the Skill to Your Agent

In SlackClaw's agent configuration panel, navigate to Skills → Add Skill → Upload Manifest. Paste or upload your YAML. SlackClaw will validate the schema and flag any missing OAuth connections. If github.list_pull_requests isn't yet authorized, you'll see a prompt to connect GitHub — one click and it's done.

Step 3: Set the Agent Instructions for This Skill

Beyond the manifest, you can provide the agent with natural language instructions that shape how it formats and contextualizes its output. In the skill's instruction field, write something like:

"When listing stale PRs, group them by repository. For each PR, include the title, author, how many days it has been open, and the last reviewer comment if one exists. If a PR has been open more than 7 days with no activity, flag it with a ⚠️ emoji. Keep the tone matter-of-fact, not judgmental."

This is where OpenClaw's agent layer shines. You're not writing code to format output — you're describing the intent, and the autonomous agent handles the rest using its reasoning capabilities combined with the live data it fetches.

Step 4: Test Before Scheduling

Use the Run Now button in the skill panel to trigger a single test execution. SlackClaw will post the output to the configured channel exactly as it would on a live schedule. Review the output in Slack, tweak the instructions if needed, and run again. Once you're happy, toggle the skill to Active and the schedule kicks in automatically on your dedicated server.

Advanced Patterns Worth Knowing

Chaining Multiple Tools in One Skill

Scheduled skills aren't limited to a single integration. A weekly engineering health report might touch GitHub for PR stats, Linear for sprint velocity, Jira for open bugs, and Notion for documentation coverage — then synthesize all of it into a single structured Slack message. List all required tools in the tools block and the agent will orchestrate the calls, handling errors and partial failures gracefully. For related insights, see OpenClaw Slack Etiquette: Guidelines for AI-Assisted Teams.

Conditional Posting

You can instruct the agent to only post when certain conditions are met. In the skill instructions, write something like: "Only post to the channel if there are more than two stale PRs. If everything looks healthy, skip the message entirely." This prevents channel noise on quiet days and ensures your team only gets pinged when there's something actionable.

Using Memory for Trend Reporting

Because SlackClaw's persistent memory persists across runs on your dedicated server, you can build skills that report on change over time rather than just the current state. An agent with memory enabled can say "Open bug count is down 12% from last week" without you maintaining any external database — it remembers last week's count automatically.

Pricing Considerations for Scheduled Skills

SlackClaw uses credit-based pricing rather than per-seat fees, which makes scheduled skills especially economical for teams. A skill that runs twice a day and touches three integrations costs the same whether one person reads the output or fifty do. You're paying for agent compute and tool calls, not headcount.

As a practical tip: start with a less frequent schedule (daily rather than hourly) while you tune the skill. Once the output is exactly what your team wants, you can increase frequency without worrying about per-user cost creep. Monitor credit usage in the SlackClaw dashboard under Usage → Skill Activity to understand the cost profile of each scheduled skill before you scale it up. For related insights, see How Consulting Firms Use OpenClaw in Slack.

Common Mistakes to Avoid

• Forgetting the timezone field: Defaulting to UTC means your morning digest arrives at 9 AM UTC, which is 4 AM in New York. Always set the timezone explicitly.
• Too many tools in one skill: If a skill touches ten different integrations, execution time increases and error surface grows. Break complex workflows into two or three focused skills.
• Skipping the test run: OAuth scopes sometimes don't cover the specific method you're calling. A test run surfaces permission errors before your 9 AM standup digest silently fails on a Monday morning.
• Vague agent instructions: "Summarize the PRs" is too open-ended. Specific instructions produce consistent, team-appropriate output — include what to include, what to omit, and how to handle edge cases.

Scheduled skills are one of the highest-leverage features in the OpenClaw ecosystem. Once deployed through SlackClaw, they run quietly in the background on your team's dedicated server, surfacing the right information at the right time — turning your Slack channels from a place where work gets discussed into a place where work gets done.