Build a Morning Briefing Agent with OpenClaw (My Real Setup)

1. What this morning briefing actually does

Instead of a generic “productivity idea,” this is a concrete workflow on my own OpenClaw instance:

• Every morning at 07:30 it compiles today’s calendar events, a few high-priority tasks, and 2–3 important updates from email/RSS.
• It sends a single message to my Telegram chat.
• It appends a short Markdown TODO file like todo-2026-07-13.md on disk so I have a local archive.

Optimized for low noise, high signal: enough to make decisions, not another long report. Example shape of the Telegram message:

Morning briefing — 2026-07-14
• 09:30 Standup (30m)
• 14:00 Vendor call — renew CDN
• Top tasks: ship cost notes; review PR #128
• Alerts: 2 from alerts@… (CI; invoice)
• RSS: gateway upgrade path worth checking

2. Architecture: from data sources to chat

1. Data sources — Google Calendar (work) + personal calendar via a small helper; IMAP on a dedicated “alerts” mailbox; a few curated RSS feeds; local notes under ~/notes/daily/.
2. OpenClaw agent — a dedicated MorningBriefing agent with calendar/email/RSS skills and a file skill for Markdown. System prompt caps output to 5–10 bullets.
3. Scheduler — cron runs a script that exports data, triggers the agent, writes the TODO file, and posts to Telegram.
4. Channel — Telegram bot to my personal chat (swap for WhatsApp, Discord, or Slack with the same pattern).

Data sources → helper scripts → OpenClaw MorningBriefing agent
        → Telegram message + ~/notes/daily/todo-YYYY-MM-DD.md

3. Prerequisites

• Running OpenClaw instance (local or VPS) — quick start / install hub
• At least one messaging channel — start with Telegram
• Credentials for calendar export, IMAP alerts mailbox, and RSS endpoints you care about
• A daily notes directory

mkdir -p ~/notes/daily

Review credential management and skills security before wiring OAuth or API keys.

4. Defining the MorningBriefing agent

Simplified example—adapt skill identifiers to your OpenClaw / ClawHub setup (agent config, ClawHub):

{
  "agents": [
    {
      "name": "MorningBriefing",
      "description": "Summarises today’s events, tasks, and key updates into one short briefing.",
      "model": "gpt-4.1-mini",
      "skills": [
        "calendar_fetch_today",
        "email_fetch_unread_alerts",
        "rss_fetch_latest",
        "file_read_write_markdown"
      ],
      "system_prompt": "You are my morning briefing assistant. Every day you will:\n- Read today’s calendar events.\n- Read high-priority tasks from my TODO list.\n- Read a small set of alerts from email/RSS.\nReturn 5-10 bullet points in less than 600 words total.\nFocus on concrete events and decisions, not generic advice.\nUse clear time references (HH:MM) and short labels.\nDo NOT include more than 3 low-priority items."
    }
  ]
}

Notes from my experiments:

• I explicitly limit word count and bullet count; otherwise the model rambles.
• High-priority tasks live in a dedicated TODO file, not mixed into endless chat memory.
• I prefer a cheaper mini-tier model for this daily job; full-size models are overkill. Cost context: cost playbook.

5. Wiring data fetching and file output

A small script runs before calling the agent. Bash shown; Python/Node is fine—the point is clear inputs and a tangible output file.

#!/usr/bin/env bash
set -e

# 1. Export today’s calendar events
python tools/export_calendar_today.py --output /tmp/openclaw_calendar_today.json

# 2. Export email alerts
python tools/export_email_alerts.py --output /tmp/openclaw_email_alerts.json

# 3. Fetch latest RSS items
python tools/export_rss_updates.py --output /tmp/openclaw_rss_updates.json

# 4. Trigger the MorningBriefing agent (official CLI: openclaw agent)
# See https://docs.openclaw.ai/cli/agent
openclaw agent \
  --agent MorningBriefing \
  --message-file /tmp/openclaw_morning_prompt.txt \
  --json > /tmp/openclaw_morning_briefing.json

# Optional: also deliver to a connected channel
# openclaw agent --agent MorningBriefing --message-file /tmp/openclaw_morning_prompt.txt --deliver

# Build a short prompt file from the exported JSON inputs (example)
python tools/compose_morning_prompt.py \
  --calendar /tmp/openclaw_calendar_today.json \
  --email /tmp/openclaw_email_alerts.json \
  --rss /tmp/openclaw_rss_updates.json \
  --out /tmp/openclaw_morning_prompt.txt

# 5. Append a plain-text extract to today’s TODO markdown
TODAY=$(date +%Y-%m-%d)
TODO_FILE=~/notes/daily/todo-$TODAY.md
echo "# TODO for $TODAY" >> "$TODO_FILE"
echo "" >> "$TODO_FILE"
# Prefer extracting .text from --json output in your helper; fallback shown:
python tools/extract_agent_text.py \
  --in /tmp/openclaw_morning_briefing.json \
  >> "$TODO_FILE"

Keep helper scripts in your own repo; the important contract is: export data → openclaw agent → write a file → optional Telegram send. Prefer OpenClaw’s built-in openclaw cron when you want schedules inside the product instead of system crontab.

6. Scheduling: every morning without thinking

# crontab -e
30 7 * * * /usr/local/bin/openclaw-morning-briefing.sh >> /var/log/openclaw/morning.log 2>&1

• I run this on a VPS so timezone and uptime are predictable.
• Logs go to a dedicated morning.log for debugging.
• First setup mistake I made: forgetting daylight-saving / server TZ. Always check timedatectl (or equivalent).

You can also use OpenClaw’s built-in scheduling if your version supports it—see cron & scheduled tasks. Cron is the simplest baseline.

7. Sending the briefing to Telegram

BRIEFING_TEXT=$(python tools/extract_agent_text.py --in /tmp/openclaw_morning_briefing.json)

python tools/send_telegram_message.py \
  --chat-id "$TELEGRAM_CHAT_ID" \
  --text "$BRIEFING_TEXT"

Or skip the helper and use openclaw agent ... --deliver when the agent is already bound to Telegram. Store tokens in environment variables—not in the script. See Telegram channel setup and credentials.

# Example env (do not commit)
export TELEGRAM_BOT_TOKEN="XXXX"
export TELEGRAM_CHAT_ID="XXXX"

8. Example briefing output (sanitized)

Morning briefing — 2026-07-13
• 09:30 Standup with eng (30m)
• 14:00 Vendor call — renew SSL / CDN
• Top tasks: ship cost playbook draft; review PR #128; backup VPS configs
• Alerts: 2 unread from alerts@… (CI failed on main; invoice reminder)
• RSS: OpenClaw patch notes — check gateway upgrade path

9. Lessons learned from daily use

• Too much information kills the value. My first version included every email and minor calendar event. Now I enforce strict caps (3–5 key items).
• Source hygiene matters. Moving noisy newsletters to a separate mailbox and curating RSS made the briefing useful.
• Local files are underrated. Markdown TODOs give a searchable archive without relying on model memory alone (memory is complementary, not a substitute).
• Cost stays low. Mini-tier model + one daily run ≈ tiny token bill; hosting is the existing VPS. Details in the cost playbook.

10. Common issues

11. Where to go next

• Life OS guide — expand briefing into a personal operating system
• Email management / calendar assistant
• PR review assistant — same “notify me on Telegram” pattern for engineering
• Second brain — archive decisions next to daily TODOs
• Security best practices before exposing any webhook