Every morning used to start the same way.
Wake up, panic a little, and try to figure out what today even is. What's on the calendar, what I forgot to reply to, what actually needs to happen before noon.
By the time I'd pieced it together, the first hour was gone — and I hadn't made a single real decision yet.
So I built a few agents that do that thinking for me. While I'm asleep.
---
The real problem: the first hour is decision fatigue
Nothing about mornings is hard. It's just a lot of small lookups, back to back, before your brain is even awake:
- Check the calendar — what's actually today?
- Check Gmail — anything urgent hiding in there?
- Figure out where my leftover to-dos even fit.
None of that is deep work. It's just friction — and friction first thing in the morning taxes the exact willpower you need for the rest of the day.
---
The idea: let agents read the signals while I sleep
The fix isn't a better to-do app. It's moving the *reading* to before I wake up, so I only have to do the *deciding*.
Three agents run overnight, each reading one signal:
1. Google Calendar — what's actually scheduled today, and where the open gaps are.
2. Gmail — anything flagged or urgent, so it isn't buried by the time I open my inbox.
3. Garmin — my sleep and recovery numbers from last night.
That third one is the part people don't expect. It's not just "what's on my plate" — it's "how rested am I for what's on my plate."
---
The part that matters: it doesn't just report, it schedules
Reading three sources and dumping them in a text would still be a wall of information to sort through at 6am. So the system goes one step further — it schedules my day around what it finds.
- Carry-overs slot into today's open gaps. Whatever didn't get done yesterday isn't a guilt list — it's placed into wherever today actually has room.
- Low-priority tasks move if recovery is low. If Garmin says I slept badly, the system doesn't ask more of me — it quietly pushes the stuff that can wait, and protects the gaps for what can't.
That second part is the whole point. The plan isn't fixed — it adjusts to the version of me that actually woke up.
---
The output: one five-line text, before the alarm
All of that — calendar, mail, recovery, the schedule it built — collapses into one message on Telegram, sent before my alarm goes off.
Five lines. I read it, and my day is already planned around how rested I actually am.
No app to open. No dashboard to check. Just five lines, and I'm already oriented.
---
Build your own (you don't need my exact setup)
You don't need all three signals on day one. Start with whichever one costs you the most morning friction:
Step 1 — Pick one signal.
Calendar is the easiest starting point — it's the one thing everyone already checks first.
Step 2 — Have something read it before you wake up.
A scheduled script (cron, or any automation tool you already use) that pulls today's events the night before or first thing at a fixed early hour.
Step 3 — Add the "what's left over" layer.
Keep a simple running list of untimed tasks. Have the same script slot them into whatever open time the calendar shows.
Step 4 — Send it to yourself, not a dashboard.
Telegram, SMS, whatever you'll actually see before you pick up your phone to scroll. A message you're handed beats a page you have to remember to open.
Step 5 — Add the recovery signal once the basics work.
If you track sleep (Garmin, Oura, Whoop — anything with an API), use it as a simple rule: recovery low → only show the must-do's, push everything else. That one rule is what turns a schedule into a schedule that adjusts to you.
You don't need all of this at once. Even step 1 through 4 — calendar plus carry-overs, sent as one message — kills most of the morning scramble on its own.
---
Why this matters
The point was never the tech. It's waking up without that scramble — reading five lines instead of reconstructing your day from four different apps.
Start with one signal. Let it read while you sleep.
*Want the exact recipe — the signals, the scheduling logic, and the five-line format? It's free below.*
---
# The Morning-Agents Setup
The exact recipe behind the system in the video — the signals it reads, the logic it schedules with, and the five-line format it sends. Adapt it with whatever tools you already have (cron + any calendar API + any messaging API is enough).
---
1. The three signals to pull
Run this before you wake up — the night before, or at a fixed early hour (mine runs before my alarm).
- Calendar — today's scheduled events, and just as important, the *gaps* between them. You need the open time, not just the busy time.
- Flagged / urgent mail — not the whole inbox. Just whatever's starred, flagged, or from a short VIP list. The goal is "anything I'd regret not seeing," not a full inbox summary.
- Recovery signal (optional, add once the basics work) — sleep quality and readiness from a wearable (Garmin, Oura, Whoop — any with an API). This is the one signal that changes *how* the day gets scheduled, not just what's in it.
Start with just the first one if you're building this from scratch. Calendar alone, sent as a clean message, already beats waking up and reconstructing the day from memory.
---
2. The scheduling logic
This is the part that turns "here's your data" into "here's your day":
Carry-overs → open gaps.
Keep one running list of untimed tasks (anything without a fixed time — a to-do, not a meeting). Each morning, slot them into whatever open time the calendar actually has today. Don't force them into a fixed order — fit them to the gaps that exist.
Low recovery → drop the low-priority stuff.
If the recovery signal says you slept badly or readiness is low, apply one rule: keep the must-do's, quietly bump the nice-to-have's to tomorrow's carry-over list. The day should ask less of a tired version of you, not the same amount.
High recovery → business as usual.
No special handling needed — just carry-overs into gaps, normal priority order.
That's the entire scheduling logic: two inputs (today's gaps, last night's recovery), one rule (recovery low → trim to essentials).
---
3. The five-line brief format
Whatever you build, keep the output to a fixed, short shape — the value is that it's *shorter* than checking the sources yourself. A format that works:
1. Today: [the day in one line — meeting count / theme / the one thing that matters]
2. Watch for: [the one flagged/urgent item, if any — else "inbox clear"]
3. Carried over: [what moved from yesterday, and where it landed today]
4. Recovery: [one line — "well rested" / "low — trimmed to essentials"]
5. First move: [the single next action, so there's zero "what do I do first" friction]
Five lines, sent as one message, before you'd normally check anything yourself.
---
4. Where to run it
You don't need a fancy stack:
- A scheduled script (cron, or any workflow tool you already use) triggered at a fixed early time.
- Calendar + mail via their standard APIs (Google Calendar API, Gmail API — both free, both well documented).
- A wearable API if you're adding recovery (Garmin Connect, Oura, Whoop all expose one).
- Telegram (or SMS) to deliver the message — a Telegram bot takes about ten lines of code and needs no app install on your end, just a chat.
---
That's the whole thing: two signals minimum (calendar + carry-overs), one optional third (recovery), one scheduling rule, and a five-line message sent before you'd normally think about any of it. Build the calendar-only version first — everything else is an upgrade, not a requirement.