How to Use AI Tools to Generate Remote Team Meeting Agendas from Previous Notes

Remote teams face a common challenge: spending precious meeting time rehashing discussions that have already happened in async channels. Instead of manually scanning through Slack threads, GitHub comments, and past meeting notes to build an agenda, you can use AI tools to automate this process. This guide shows you how to build a workflow that transforms scattered notes into structured, actionable meeting agendas.

The Problem with Manual Agenda Building

When you’re managing a distributed team, relevant information lives across multiple platforms. Your sprint planning notes might be in Notion, design decisions in Figma comments, and technical discussions in Slack channels. Building a meeting agenda traditionally requires manually gathering these disparate inputs—a time-consuming process that often misses critical context.

AI tools excel at pattern recognition across large volumes of text. By feeding previous notes into an AI system, you can automatically extract action items, identify recurring topics, and surface decisions that need follow-up.

Building Your AI Agenda Generator

Here’s a practical approach using a simple Python script that works with most AI APIs:

import os
import json
from datetime import datetime, timedelta

# Configuration
NOTES_DIR = "./meeting-notes"
OUTPUT_FILE = "./agenda-output.md"

def gather_recent_notes(days=14):
    """Collect all notes from the past N days."""
    notes = []
    cutoff = datetime.now() - timedelta(days=days)

    for filename in os.listdir(NOTES_DIR):
        if not filename.endswith('.md'):
            continue
        filepath = os.path.join(NOTES_DIR, filename)
        mtime = datetime.fromtimestamp(os.path.getmtime(filepath))

        if mtime > cutoff:
            with open(filepath, 'r') as f:
                notes.append({
                    'filename': filename,
                    'content': f.read(),
                    'date': mtime.isoformat()
                })

    return notes

def build_prompt(notes):
    """Create a prompt that instructs the AI to build an agenda."""
    combined_notes = "\n\n---\n\n".join(
        f"## {n['filename']} ({n['date']})\n{n['content']}"
        for n in notes
    )

    return f"""Analyze the following meeting notes and build a structured meeting agenda.

Requirements:
1. Identify key discussion points and decisions made
2. List all action items with their owners
3. Note any topics that need follow-up discussion
4. Group related items together

Notes:
{combined_notes}

Output a markdown-formatted agenda with these sections:
- Quick Recap (key decisions)
- Action Items Review
- Discussion Topics (prioritized)
- New Business
"""

# Example usage with OpenAI
def generate_agenda(notes, api_key=None):
    from openai import OpenAI

    client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a meeting facilitator who creates clear, actionable agendas."},
            {"role": "user", "content": build_prompt(notes)}
        ],
        temperature=0.3
    )

    return response.choices[0].message.content

if __name__ == "__main__":
    notes = gather_recent_notes()
    agenda = generate_agenda(notes)

    with open(OUTPUT_FILE, 'w') as f:
        f.write(f"# Meeting Agenda - {datetime.now().strftime('%Y-%m-%d')}\n\n")
        f.write(agenda)

    print(f"Agenda generated: {OUTPUT_FILE}")

This script collects markdown files from a designated folder, sends them to an AI model, and returns a structured agenda. You can customize the prompt to match your team’s specific needs.

Integrating with Your Existing Tools

For a more integrated solution, consider connecting your AI agenda generator to your existing workflow:

Slack Integration: Use Slack’s API to pull relevant messages from specific channels before meetings. This catches discussions that happen in real-time but don’t get documented elsewhere.

def get_slack_notes(channel_id, days=7):
    from slack_sdk import WebClient

    client = WebClient(token=os.getenv("SLACK_BOT_TOKEN"))
    result = client.conversations_history(
        channel=channel_id,
        limit=1000,
        oldest=(datetime.now() - timedelta(days=days)).timestamp()
    )

    messages = [msg['text'] for msg in result['messages']
                if 'action-item' in msg['text'].lower()
                or 'decision:' in msg['text'].lower()]

    return "\n".join(messages)

GitHub Integration: Pull issue comments and PR discussions for engineering-focused teams:

def get_github_notes(owner, repo, days=7):
    import requests

    url = f"https://api.github.com/repos/{owner}/{repo}/issues"
    params = {
        "since": (datetime.now() - timedelta(days=days)).isoformat(),
        "state": "all"
    }

    response = requests.get(url, params=params)
    issues = response.json()

    # Extract issues with specific labels
    relevant = [f"#{i['number']}: {i['title']}" for i in issues
                if 'meeting-agenda' in [l['name'] for l in i.get('labels', [])]]

    return "\n".join(relevant)

Best Practices for AI-Generated Agendas

Provide context in your prompts: The quality of your agenda depends heavily on the instructions you give the AI. Include specifics about your team’s meeting format, recurring topics, and priority criteria.

Review before distributing: AI generates solid drafts, but always review for accuracy. The tool assists your preparation—it doesn’t replace your judgment about what matters.

Iterate on the prompt: Keep notes on what works. If action items get missed, add that to your system prompt. If priorities seem off, adjust the instructions.

Maintain a notes archive: The more historical data you feed the system, the better it becomes at identifying patterns. Consistent note-taking pays dividends.

Extracting Action Items Automatically

One of the most valuable features is automatic action item extraction. Configure your AI to specifically look for:

Tasks assigned to team members
Decisions that need follow-up
Blockers mentioned in discussions
Items deferred to future meetings

def extract_action_items(notes_content):
    prompt = f"""Extract all action items from this text. For each item, identify:
1. What needs to be done
2. Who is responsible (if mentioned)
3. When it's due (if mentioned)

Format as a markdown table.

Text:
{notes_content}
"""
    # Call AI with this prompt
    return action_items

Putting It All Together

The real power comes from combining multiple data sources. A complete agenda pipeline might pull from:

Previous meeting notes (your local archive)
Slack channels with specific keywords
GitHub issues labeled for discussion
Email threads flagged for meetings
Project management tool updates

Each source adds context. The AI serves as the aggregator, transforming noise into signal.

Built by theluckystrike — More at zovo.one