Playbook

Build an AI Meeting Preparation Agent (Outlook + Teams + Calendar)

AI Meeting Preparation Agent

Overview

What it is. An agent that runs automatically before every meeting on your calendar. It reads the meeting invite (title, attendees, agenda), figures out the topic, then reaches into your Outlook mail, Teams chats/channels, project files and past calendar events to gather everything relevant. It hands you a single, short prep brief made of four sections: Meeting Summary, Latest Updates, Open Action Items, and Suggested Discussion Points.

The problem. Before a meeting most of us spend 15–30 minutes hunting: scrolling email threads, opening the shared drive, scanning Teams for the last decision, trying to remember what we committed to last time. It is slow, it is stressful, and we still walk in having missed something.

The impact. The prep is done for you in seconds and it is consistent every time. You arrive knowing the current state, the open commitments, and the exact questions worth raising. Meetings get shorter because nobody spends the first ten minutes re-establishing context.

The lesson from the video. Good preparation makes the meeting itself shorter and more effective. Move the effort from "during the meeting" to "automatically before it," and the meeting becomes a decision, not a briefing.

Full system prompt (copy-paste)

text

You are a Meeting Preparation Agent for a government/enterprise employee.
Your job: turn a set of retrieved source materials about an upcoming meeting into
a short, accurate, decision-ready prep brief.

INPUTS you will receive (as structured JSON):
- meeting: { title, start_time, end_time, location, organizer, attendees[], agenda_text }
- sources: an array of retrieved items, each shaped:
    {
      source_type: "outlook_email" | "teams_message" | "file" | "calendar_event",
      source_id:   <stable id>,
      title:       <subject / filename / event title>,
      author:      <sender / poster / owner>,
      timestamp:   <ISO 8601>,
      url:         <deep link to open the item>,
      content:     <plain-text body or extracted text>
    }
- user_context: { display_name, role, team, language_preference }

OUTPUT: exactly four sections, in this order, using these headings:
  1. Meeting Summary
  2. Latest Updates
  3. Open Action Items
  4. Suggested Discussion Points

RULES:
1. NEVER fabricate. Every factual claim must trace to a provided source. If the
   sources do not cover something the meeting clearly needs, say so explicitly
   under the relevant section ("No recent update found on X").
2. CITE sources inline. After each bullet, add a compact citation like
   [Outlook — "Q3 budget", 2 days ago] or [Teams — @author, yesterday]. Prefer
   the most recent source when items conflict, and note the conflict.
3. BE CONCISE. Bullets, not paragraphs. Target a brief a busy person reads in
   under 60 seconds. Merge duplicates. Drop anything not relevant to THIS meeting.
4. RANK BY RECENCY + RELEVANCE. Newest, most decision-relevant items first.
5. OPEN ACTION ITEMS must include, where known: the action, the owner, the due
   date, and current status. Flag overdue items.
6. SUGGESTED DISCUSSION POINTS are the questions/decisions the user should raise —
   derived from gaps, blockers, conflicting information, and overdue actions.
7. MATCH LANGUAGE. Write the brief in user_context.language_preference. If sources
   are mixed-language, summarize faithfully in the user's language and keep proper
   nouns/quoted decisions in their original form.
8. RESPECT SENSITIVITY. Do not restate secrets, credentials, or personal data
   beyond what is needed for prep. Never invent attendee opinions.
9. If a section has nothing, write one honest line rather than padding.

TONE: neutral, professional, first-person-neutral (address the reader as "you").
Do not add preamble, sign-off, or explanation outside the four sections.

How it works & wiring

The agent is a scheduled pipeline with four stages. Everything reads from Microsoft Graph, so one set of delegated permissions covers mail, chat, files and calendar.

Trigger — before a calendar event.
- Poll GET /me/calendarView?startDateTime=...&endDateTime=... on a schedule (e.g. every 15 min), or subscribe to a Graph change notification on the calendar.
- For each event starting in the next window (e.g. 30–60 min ahead) that hasn't been prepped, kick off the pipeline. Deduplicate on event.id.
Understand the meeting.
- Extract topic signals: subject, body/agenda, attendees, and any linked files in the invite.
- Build a query set = keywords from the title/agenda + attendee names + any project/ticket codes found.
Gather (fan-out retrieval across sources).
- Outlook mail: GET /me/messages?$search="<topic terms>"&$top=15&$orderby=receivedDateTime desc — recent threads with the attendees or about the topic.
- Teams: GET /me/chats/getAllMessages / channel messages filtered by keyword and participants; capture the last decisions and updates.
- Project files: GET /me/drive/root/search(q='<topic>') and relevant SharePoint doc libraries; pull modified-recently docs, extract text (server-side or via a text-extraction step).
- Calendar history: prior events with the same series/attendees and their notes/minutes.
- Normalize every hit into the sources[] shape from the system prompt (type, id, title, author, timestamp, url, content). Trim each content to the most relevant passages to control token size.
Summarize + deliver.
- Send meeting, sources[], and user_context to the LLM (Azure OpenAI / Copilot) with the system prompt above.
- Take the four-section output and deliver it: an Outlook email to the user ~30 min before start, an Adaptive Card in Teams, and/or a note attached to the calendar event. Include the source deep links so any bullet is one click from the original.

Guardrails: use delegated (on-behalf-of the user) permissions so the agent only ever sees what the user can already see; log which sources were retrieved; never write back to source systems.

Output format

The brief is always these four sections, in order. Keep it to one screen.

code

## Meeting Summary
- One or two lines: what this meeting is about, why it's happening now, who's in it.
- The current state of the topic in a sentence.

## Latest Updates
- <Newest relevant change> [Source — title, when]
- <Next change> [Source — author, when]
- (Newest first. Note any conflicting information and which source is more recent.)

## Open Action Items
- <Action> — Owner: <name> — Due: <date> — Status: <status/OVERDUE> [Source]
- (Everything still open that touches this meeting. Flag overdue.)

## Suggested Discussion Points
- <Question or decision to raise, derived from a gap/blocker/conflict/overdue item>
- <Decision needed today and who must sign off>

Field mapping to what's shown on screen: Meeting Summary = the framing paragraph; Latest Updates = recency-ranked changes with citations; Open Action Items = owner/due/status list; Suggested Discussion Points = the raise-these questions.

Build it

Option A — No/low-code (Power Automate + Azure OpenAI / Copilot)

Fastest path if you're in Microsoft 365.

Trigger: Power Automate flow → "When an upcoming event is starting soon" (Office 365 Outlook connector), or a Recurrence every 15 minutes that lists events in the next hour.
Gather: add actions to pull context — Outlook "Get emails (V3)" with a search on the meeting subject; Teams connector "Get messages" from relevant chats/channels; OneDrive/SharePoint "Find files" + "Get file content". Compose the results into one array.
Summarize: Azure OpenAI connector (or a Copilot / HTTP action to your model) — system message = the prompt above, user message = the composed meeting + sources[] JSON.
Deliver: "Send an email (V2)" to yourself with the four-section brief, and/or "Post an Adaptive Card in a chat" (Teams) 30 minutes before start.
Dedup: store handled event.ids in a small Dataverse/SharePoint list so a meeting is prepped once.

Even lower-code: a Copilot Studio agent with Graph connectors and a scheduled topic can do steps 2–4 with the same system prompt as its instructions.

Option B — Custom (Graph API + LLM + scheduler)

Full control, portable off the Microsoft stack for the LLM.

Auth: register an Entra ID app; request delegated scopes Calendars.Read, Mail.Read, Chat.Read, ChannelMessage.Read.All, Files.Read.All. Use on-behalf-of / delegated tokens so the agent inherits the user's own access.
Scheduler: a cron job / Azure Function timer / APScheduler task that calls calendarView for the look-ahead window and enqueues un-prepped events.
Retrieval service: functions per source (searchMail, searchTeams, searchFiles, pastEvents) that hit Graph, extract text (use a doc text-extractor for Office/PDF), and normalize into sources[]. Cap tokens by trimming to top-N most relevant passages (embed + rank, or keyword score).
LLM call: POST meeting + sources + user_context to your model (Azure OpenAI chat/completions, or any LLM) with the system prompt. Keep temperature low (≈0.2) for faithful, non-creative output.
Delivery: send via Graph sendMail, a Teams Adaptive Card, or attach to the event body. Persist a record of prepped events + which sources fed each brief (for audit + debugging).

Ops notes: rate-limit Graph calls and honor Retry-After; cache per-event so re-runs are cheap; log source ids for traceability; keep the LLM stateless (all context in the prompt) so it's easy to swap models.

Example output

Filled-in brief for a real-shaped meeting.

Meeting: Q3 Digital Services Rollout — Weekly Sync · Tomorrow 10:00–10:30 · Organizer: Fatima H. · Attendees: you, Fatima H., Omar K., Vendor (Nexlar)