Build Your Personal Assistant Operating System

3.5

Keep Promises and Deadlines From Disappearing

People forget commitments more often than they forget information

You remember the meeting happened. You remember who was there. You forget that you said 'I will send the revised numbers by Thursday.' The information survives; the promise vanishes. Two weeks later, Sarah follows up and you realize you never sent the numbers. The failure is tracking, and you already have the data to fix it.

This chapter turns tracking into a set of projects you can build and test. A promise detector scans your email and meeting notes for language that signals a . A waiting-on tracker monitors what others owe you. A deadline radar surfaces conflicts and compression. Together, they form a commitment layer that sits on top of and prevents promises from disappearing into the stream of daily work.

The emotional weight matters here. Breaking a promise is different from forgetting a fact. When the system catches a before it slips, the value is not just productivity. It is trust preserved.

A stylized teaching image showing promises and deadlines being extracted from daily communication and tracked in a commitment layer — The layer catches promises before they slip through the cracks of daily communication.

A promise detector catches the commitments you made without thinking about them

Most commitments are made casually. 'I will look into that.' 'Let me get back to you.' 'I will loop in the team.' These phrases feel like conversation, and they are commitments. The promise detector scans email threads, meeting notes, and messages for language patterns that signal a promise: 'I will,' 'I can,' 'let me,' 'by Friday,' 'next week,' and similar phrases.

For each detected promise, the assistant proposes a task record: what was promised, who it was promised to, when it is due (explicit or inferred), and the source where the promise appeared. You review the proposals and approve, correct, or discard.

The promise detector catches the commitments your calendar and task list never see. You add explicit tasks to your task list. You rarely add casual promises. The detector fills that gap by reading the same communication you already produce.

A waiting-on tracker prevents other people's promises from silently expiring

The promise detector works in both directions. When someone else promises something to you, the assistant creates a waiting-on record: what was promised, who promised it, when it is due, and how long it has been outstanding. These records surface in the morning brief and the .

After twelve days without the feedback David promised, the morning brief says: 'You have been waiting on David Park for 12 days. He committed to design feedback by last Wednesday. Suggested action: follow up.' The waiting-on tracker turns a forgotten thread into a visible item.

The tracker does not contact anyone. It does not send reminders on your behalf. It surfaces the stale item and suggests an action. You decide whether to follow up, extend the deadline, or drop the request.

A deadline radar flags conflicts and compression before they become crises

Deadlines live in multiple places: email threads, calendar events, task records, project milestones, and verbal commitments from meetings. The deadline radar extracts all of them into one timeline and flags two patterns: conflicts (two deadlines on the same day) and compression (three deadlines within 48 hours while your calendar shows five hours of meetings).

The radar runs as part of the morning brief. When it flags compression, the brief says: 'You have three deliverables due by Thursday, and your calendar shows back- to-back meetings until 3 PM. The proposal for Maria is the lowest-weight task; consider asking for a one-day extension.' The suggestion is there for your judgment. The radar surfaces the pattern; you decide what to do.

A three-things generator turns the task universe into today's priorities

The task already sorts by weight and energy. The three-things generator adds : which of your tasks are promises to other people? Which have been waiting the longest? Which block someone else's work? It produces a daily output of three items: if you do nothing else today, do these.

The three-things output uses four inputs: task weight (importance times urgency), age (how long since you made the promise), dependency pressure (does someone else's work depend on yours?), and calendar availability (how much free time do you actually have today?). The result is the three items that matter most given the constraints, pulled from the full task list.

Three items is the right number because it fits in working memory. A list of twelve priorities is a list of zero priorities. Three items can be held in mind throughout the day, checked off, and replaced. If you finish all three, ask for the next three.

A slipping- review catches promises that keep carrying forward

Some tasks carry forward week after week without getting done. The already catches these, and the slipping- review adds a specific lens: which of these carried-forward items are commitments to other people?

When the review surfaces a that carried forward three times, it asks: should you keep this commitment (and schedule focused time)? Renegotiate the deadline? Delegate the task? Or acknowledge that you are not going to do it and communicate that honestly? The review frames these as choices, and each choice becomes a record.

The review does not judge. It surfaces the facts and frames the choices. The honest version of tracking includes acknowledging when a commitment needs to be renegotiated or released. A system that only reminds you of overdue items without offering alternatives produces guilt, not action.

How this module breaks

What goes wrong	How you notice	What to correct once	What rule to save
The promise detector creates tasks from polite language that is not a real .	Your task list fills with items like 'look into that thing David mentioned' when you were just being conversational.	Add a specificity filter: a detected promise needs a deliverable (what), a recipient (who), and either an explicit or inferable deadline (when). Vague language without all three is logged as a note, not a task.	A promise becomes a task record only when it has a deliverable, a recipient, and a deadline (explicit or inferable). Vague commitments are logged as notes for optional review.
The waiting-on tracker surfaces items from people who have already delivered but through a channel the assistant did not see.	The morning brief says 'waiting on David for 14 days' when David sent the feedback via Slack, which is not a connected source.	When the waiting-on alert appears, check whether the item was delivered through another channel. Mark it as received and note the channel gap for future connector decisions.	Waiting-on alerts include a note: 'Check other channels (Slack, in-person) if this has already been delivered.' Marking an item as received updates the record and stops future alerts.
The deadline radar flags every minor overlap as a crisis.	The morning brief has six compression warnings every day, and you start ignoring all of them.	Set a threshold: only flag compression when the total estimated work hours for due-this-week tasks exceed the available free hours on the calendar by more than 20%.	Compression warnings require a mismatch of more than 20% between estimated work hours and available calendar hours. Minor overlaps are noted in the full task list without a flag.

Your turn

Build a promise detector from your recent email and meeting notes

You'll produce a list of active commitments from your email and meetings, with task records proposed for each one.

Why this exercise matters

Commitments are the promises that connect your work to other people. A promise detector catches the ones that slip through your task list.

You’ll leave with

A list of your active promises with deliverables, recipients, and deadlines.
A list of waiting-on items with owners, due dates, and age.
Task records proposed for each commitment.
At least one commitment you had forgotten about.

Use the prompt in order

1
Give the assistant your recent emails and meeting notes
Connect your email or paste representative threads from the past two weeks. Include meeting notes or summaries. The assistant scans for language: 'I will,' 'by Friday,' 'let me,' 'can you,' 'we agreed,' and similar patterns.
2
Review the detected promises for accuracy
The assistant will propose a list of commitments. Check each one: is it a real or just polite conversation? Does the deadline match what was agreed? Is the recipient correct?
3
Separate your commitments from waiting-on items
Your commitments become tasks with deadlines. Others' commitments become waiting-on items with follow-up dates. Review the separation and correct any misattributed promises.
4
Approve records into shared memory and check the morning brief
Save the approved commitments as task records and waiting-on records. The next morning brief should include at least one from this scan.

Prompt details

Each detail will be inferred, or you will be asked to clarify in the chat.

1/1 details

1 detail will be inferred, or you will be asked to clarify in the chat

Starter prompt text

Open the full text if you want to check what will be copied.

Show starter prompt

Scan my recent email threads and meeting notes for commitments.

Sources:
Infer from what you know about me or ask if it is unclear

For each commitment found, extract:
1. Who made the promise (me or someone else).
2. What was promised (the deliverable).
3. Who it was promised to (the recipient).
4. When it is due (explicit deadline or inferred from context).
5. Source (email thread, meeting notes, message).

Separate into two lists:
- My commitments: things I promised to do. Propose as task records.
- Waiting on: things others promised me. Propose as waiting-on records with
  a follow-up date.


Filter: only include commitments with a clear deliverable and recipient. Skip vague conversational language ('I should probably,' 'we might') unless it has a specific deadline attached.

What the answer should give you

Eight commitments detected: five from you (two with explicit deadlines, three with inferred deadlines) and three waiting-on items (one overdue by six days). Task records proposed for each. One commitment you had forgotten: a promise to loop in the design team, made nine days ago with no follow-up.