Build an Automated Daily Morning Briefing with AI Agents

Mar 27, 2026

Purpose

This post shows how to build an automated daily morning briefing using AI agents. The key insight: consolidation over complexity. Instead of checking 5 different apps each morning, you get one summary in 30 seconds.

The Problem

Every morning, I followed the same ritual. Open calendar. Check for meetings. Open email. Scan for urgent messages. Open weather app. Plan my outfit. Open news apps. Skim headlines. Open Slack. Check overnight messages.

This context-switching wasted time and mental energy before my day even started. I calculated I spent about 20 minutes each morning just gathering information.

I wanted one place to see everything important. A single briefing that took 30 seconds to read, not 20 minutes to collect.

The Solution

I built an AI-powered morning briefing that consolidates:

Today’s calendar events
Priority emails
Weather forecast
News on topics I track

Delivered to Telegram at 7 AM every day.

How It Works

The architecture is straightforward:

+-------------------------------------------------------------+
|                    AI Agent (OpenClaw/Claude)               |
|  +-----------+  +-----------+  +-----------+  +----------+  |
|  | Calendar  |  |   Email   |  |  Weather  |  |   News   |  |
|  |   API     |  |   API     |  |   API     |  |   APIs   |  |
|  +-----------+  +-----------+  +-----------+  +----------+  |
|        |              |              |              |        |
|        +--------------+--------------+--------------+        |
|                              |                              |
|                    +---------v---------+                    |
|                    |  Synthesis Engine |                    |
|                    |  (Claude/LLM)     |                    |
|                    +---------+---------+                    |
|                              |                              |
|                    +---------v---------+                    |
|                    |  Telegram Bot API |                    |
|                    +-------------------+                    |
+-------------------------------------------------------------+

The AI agent pulls data from multiple APIs, synthesizes it into a coherent summary, and sends it to Telegram. Nothing revolutionary - just aggregation done right.

Implementation

Step 1: Choose Your Platform

I tested two options:

OpenClaw (recommended for beginners):

Pre-built agent orchestration
Native Telegram integration
Setup time: ~30 minutes

Custom Claude Agent:

More control and customization
Requires API integration work
Setup time: 2-4 hours

I started with OpenClaw for quick results, then built a custom agent for more control.

Step 2: Connect Data Sources

Each source needs different credentials:

Source	Integration	What You Need
Google Calendar	Google Calendar API	OAuth 2.0 tokens
Email	Gmail API	OAuth 2.0 or app password
Weather	OpenWeatherMap API	API key (free tier available)
News	RSS feeds	Just the feed URLs

Step 3: Configure with OpenClaw

OpenClaw uses a YAML configuration file:

name: morning-briefing
description: Daily morning briefing over Telegram
trigger:
  schedule: "0 7 * * *"  # 7 AM daily
  timezone: "America/New_York"

sources:
  calendar:
    type: google_calendar
    scope: "calendar.readonly"
    max_events: 10

  email:
    type: gmail
    scope: "gmail.readonly"
    query: "is:unread OR is:important"
    max_results: 5

  weather:
    type: openweathermap
    location: "New York, NY"
    units: imperial

  news:
    type: rss_aggregator
    feeds:
      - "https://feeds.arstechnica.com/arstechnica/index"
      - "https://www.reddit.com/r/technology/.rss"

output:
  channel: telegram
  bot_token: "${TELEGRAM_BOT_TOKEN}"
  chat_id: "${TELEGRAM_CHAT_ID}"

Step 4: Define the Briefing Template

I created a simple template for consistent formatting:

## Good Morning! Here's your briefing for {date}

### Calendar Today
{#each events}
- **{time}**: {title} {#if location}@ {location}{/if}
{/each}

### Priority Emails
{#each emails}
- **{sender}**: {subject}
  _{summary}_
{/each}

### Weather
{weather.condition}, {weather.temp}F
Feels like {weather.feels_like}F
{weather.recommendation}

### News Highlights
{#each news_items}
- **{source}**: {headline}
{/each}

---
_Briefing generated in {generation_time}ms_

Step 5: Custom Python Implementation

For more control, I built a custom agent:

import os
from datetime import datetime
from anthropic import Anthropic
import requests

class MorningBriefing:
    def __init__(self):
        self.client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
        self.telegram_token = os.environ["TELEGRAM_BOT_TOKEN"]
        self.telegram_chat_id = os.environ["TELEGRAM_CHAT_ID"]

    def get_calendar_events(self):
        # Integrate with Google Calendar API
        # Return list of today's events
        pass

    def get_weather(self, location="New York"):
        api_key = os.environ["OPENWEATHER_API_KEY"]
        url = "https://api.openweathermap.org/data/2.5/weather"
        params = {"q": location, "appid": api_key, "units": "imperial"}
        return requests.get(url, params=params).json()

    def synthesize_briefing(self, calendar, weather, emails, news):
        prompt = f"""Create a concise morning briefing from the following data.
        Keep it under 300 words. Focus on actionable information.

        Calendar: {calendar}
        Weather: {weather}
        Emails: {emails}
        News: {news}
        """

        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=500,
            messages=[{"role": "user", "content": prompt}]
        )
        return response.content[0].text

    def send_to_telegram(self, message):
        url = f"https://api.telegram.org/bot{self.telegram_token}/sendMessage"
        data = {
            "chat_id": self.telegram_chat_id,
            "text": message,
            "parse_mode": "Markdown"
        }
        requests.post(url, data=data)

    def run(self):
        calendar = self.get_calendar_events()
        weather = self.get_weather()
        # ... gather other sources

        briefing = self.synthesize_briefing(calendar, weather, [], [])
        self.send_to_telegram(briefing)

The Reddit Story

I discovered this use case from a Reddit thread asking “What is your best use case of OpenClaw thus far?”

The top-voted answer from user ShabzSparq:

“The most boring answer but genuinely.. daily morning briefing over Telegram. Calendar for the day, email summary, weather, any news on topics I’m tracking. Takes 30 seconds to read and saves me like 20 minutes of checking 5 different apps.”

The OP (dhruvkar) replied: “Love it. It’s such an unlock!”

This confirmed my approach. The value isn’t in doing something new - it’s in consolidating what you already do.

What I Learned

Mistake 1: Over-loading the Briefing

My first version included too much. I added:

Full email bodies (not summaries)
20 news articles instead of 5
Detailed weather forecasts for the whole week

The briefing took 5 minutes to read. This defeated the purpose. I learned to include only actionable or time-sensitive information.

Mistake 2: Ignoring Privacy

I initially sent full email content to the AI. This included sensitive information like:

Password reset links
Financial statements
Personal correspondence

I now filter emails by sender and subject before including them in the briefing. Calendar events are limited to title, time, and location - no meeting notes.

Mistake 3: No Fallback

One morning, the OpenWeatherMap API was down. My briefing showed “Weather: Error fetching data” with no context. I added a fallback that includes yesterday’s forecast as a backup.

What Worked

Keep it short. My current briefing is under 300 words. I can read it while my coffee brews.

Use a consistent format. Same structure every day. My brain knows where to look for each type of information.

Start small, expand later. I began with just calendar and weather. Added email after a week. Added news after another week. This let me tune each component before adding more.

Time Savings

Let me break down the math:

Task	Before	After
Check calendar	2 min	0 min (in briefing)
Check email	5 min	1 min (scan summary)
Check weather	1 min	0 min (in briefing)
Check news	8 min	2 min (scan headlines)
Check Slack	4 min	3 min (less urgent)
Total	20 min	6 min + 30 sec briefing

That’s about 14 minutes saved per day. Over a year, that’s 85 hours recovered.

Extending the Briefing

Once I had the basic version working, I added:

Weekly planning on Mondays:

Upcoming events for the week
Project deadlines
Recurring commitments

End-of-week summary on Fridays:

Completed tasks
Pending items
Weekend weather

Custom triggers:

Rain alert the night before (brings umbrella)
Heavy traffic alert (suggests leaving early)

The system is flexible enough to add new sources without rebuilding everything.

Summary

In this post, I showed how to build an automated daily morning briefing using AI agents. The key insight: consolidation over complexity. By connecting calendar, email, weather, and news APIs to an AI agent, you can deliver a 30-second summary that saves 20 minutes of morning context-switching.

What I recommend:

Start with OpenClaw for quick setup
Connect 2-3 essential sources (calendar, weather, email)
Keep the briefing under 300 words
Filter sensitive information before sending to AI
Add complexity only after the basic version works

The 30-minute investment to set up this automation pays dividends of 120+ hours annually - time better spent on meaningful work than app-hopping each morning.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!