How to Use Claude for Meeting Summarisation and Action Item Tracking

Your organisation runs on meetings. Engineering standups, client calls, board reviews, sprint retrospectives — each one generates decisions, commitments, and action items that need to be captured, distributed, and tracked. Most organisations do this badly. Notes are inconsistent, action items live in someone's inbox, and three weeks later nobody remembers who committed to what.

Claude meeting summarisation eliminates this friction. Connect Claude to your transcription pipeline, and every meeting automatically produces a structured summary, a clear action item list with owners and deadlines, and a searchable record that feeds directly into your project management and CRM systems. This guide walks through the complete implementation: from raw transcript to automated Jira tickets and Slack follow-ups.

If you want this deployed across your organisation rather than built from scratch, our Claude API Integration service handles the full build. If you're evaluating the approach first, keep reading.

Step 1: Getting Transcripts Into the Pipeline

Before Claude can summarise meetings, you need transcripts. The good news: every major meeting platform now produces transcripts natively or via third-party integrations.

Zoom

Zoom's AI Companion (or manual recording transcription) generates VTT files with speaker diarisation. Download these via the Zoom API using the GET /meetings/{meetingId}/recordings endpoint. You'll need a Server-to-Server OAuth app in the Zoom App Marketplace with recording:read:admin scope. The VTT format includes speaker labels and timestamps — preserve these when passing to Claude, as they're essential for attributing action items to the right person.

Microsoft Teams

Teams produces transcripts through Microsoft Graph API. Use GET /communications/callRecords/{id}/sessions to access session data, then GET /communications/callRecords/{id}/sessions/{sessionId}/segments for transcript segments. For organisations already using Microsoft 365 integrations, this fits naturally into existing Graph API workflows. Ensure you have CallRecords.Read.All permission in your Azure AD app registration.

Google Meet

Google Meet transcripts are stored in Google Drive when enabled by Workspace admins. Access them via the Google Drive API by listing files with mimeType='application/vnd.google-apps.document' filtered by the meeting-generated naming convention. For real-time integration, use Google Cloud Pub/Sub to receive notifications when new transcript documents are created.

Third-Party: Granola, Otter.ai, Fireflies

If your organisation uses a dedicated meeting recorder, these platforms all have webhook APIs that push transcript data as soon as a meeting ends. Granola in particular has strong MCP integration potential — you can build an MCP server that connects Claude directly to your Granola workspace for on-demand meeting search and summarisation.

Step 2: Transcript Preprocessing

Raw meeting transcripts require preprocessing before they're useful for Claude. A 90-minute engineering planning meeting produces 15,000–25,000 tokens of raw transcript — well within Claude's 200K context window, but expensive if you're processing hundreds of meetings per week. Smart preprocessing reduces cost and improves output quality.

Cleaning the Transcript

import re

def clean_transcript(raw_vtt: str) -> str:
    """Convert VTT transcript to clean speaker-labeled text."""
    lines = raw_vtt.strip().split('\n')
    output = []
    current_speaker = None
    current_text = []

    for line in lines:
        # Skip VTT header and timestamp lines
        if line.startswith('WEBVTT') or '-->' in line or line.strip().isdigit():
            continue
        # Speaker label (e.g., "John Smith: ")
        if ':' in line and len(line) < 80 and line.split(':')[0].strip().replace(' ', '').isalpha():
            if current_speaker and current_text:
                output.append(f"{current_speaker}: {' '.join(current_text)}")
                current_text = []
            current_speaker = line.split(':')[0].strip()
            remainder = ':'.join(line.split(':')[1:]).strip()
            if remainder:
                current_text.append(remainder)
        elif line.strip():
            current_text.append(line.strip())

    if current_speaker and current_text:
        output.append(f"{current_speaker}: {' '.join(current_text)}")

    return '\n'.join(output)

def remove_filler_words(text: str) -> str:
    """Remove common filler words that inflate token count."""
    fillers = r'\b(um|uh|like|you know|sort of|kind of|basically|literally)\b'
    return re.sub(fillers, '', text, flags=re.IGNORECASE)

Context Enrichment

Before passing the transcript to Claude, append meeting metadata: meeting title, date, participant list, and (if available) the meeting agenda. This context dramatically improves action item attribution — Claude needs to know that "the CTO" is David Chen to produce useful output. Build a metadata lookup that maps your calendar event to this structured context object.

Step 3: Claude Summarisation Prompts

Meeting summarisation is one of the highest-value, lowest-risk Claude use cases. The output is always reviewed by a human before acting on it, which means the cost of imperfect output is low. What matters is consistency: every meeting summary should follow the same structure so that your teams know exactly where to look for decisions, action items, and blockers.

The Core Summarisation Prompt

import anthropic

client = anthropic.Anthropic()

SUMMARISATION_SYSTEM = """You are a professional meeting analyst. Your job is to extract
structured information from meeting transcripts with precision.

Always return a JSON object with these exact fields:
- "title": one-sentence meeting title (max 80 chars)
- "executive_summary": 2-4 sentences summarising what was discussed and decided
- "key_decisions": list of concrete decisions made (not discussions, only decisions)
- "action_items": list of objects with { "task", "owner", "deadline", "priority" }
- "blockers": list of issues that are blocking progress
- "next_meeting": suggested agenda for follow-up (if mentioned)
- "participants_and_roles": inferred roles for each speaker

Rules:
- Only include action items where a specific person committed to a task
- Mark deadline as "TBD" if not specified — never invent deadlines
- Priority is "HIGH", "MEDIUM", or "LOW" based on urgency signals in the transcript
- Do not include discussion points that led to no decision or commitment"""

def summarise_meeting(transcript: str, metadata: dict) -> dict:
    context = f"""
Meeting: {metadata.get('title', 'Unknown')}
Date: {metadata.get('date', 'Unknown')}
Participants: {', '.join(metadata.get('participants', []))}
Agenda: {metadata.get('agenda', 'No agenda provided')}

TRANSCRIPT:
{transcript}
"""
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        system=SUMMARISATION_SYSTEM,
        messages=[{"role": "user", "content": context}]
    )

    import json
    return json.loads(response.content[0].text)

Example Output

Model Selection for Meeting Summarisation

Claude Sonnet is the right model for routine meeting summarisation. It's significantly cheaper than Opus while producing summaries that are functionally indistinguishable for 90% of meetings. Reserve Claude Opus for high-stakes meetings (board meetings, M&A discussions, major client negotiations) where nuance and depth justify the cost. Use Claude Haiku for preprocessing tasks like filler word removal or speaker label normalisation. See our model comparison guide for detailed cost-performance analysis.

Step 4: Action Item Tracking and Distribution

A meeting summary that lives in a shared Google Doc is still a failure mode. Action items need to enter your existing task management system automatically — otherwise you've just added a more readable format to the same broken workflow.

Creating Jira Tickets from Action Items

import requests

JIRA_URL = "https://your-org.atlassian.net"
JIRA_PROJECT = "SPRINT"

def create_jira_ticket(action_item: dict, meeting_title: str) -> str:
    """Create a Jira ticket from a meeting action item."""
    payload = {
        "fields": {
            "project": {"key": JIRA_PROJECT},
            "summary": action_item["task"],
            "description": {
                "type": "doc",
                "version": 1,
                "content": [{
                    "type": "paragraph",
                    "content": [{
                        "type": "text",
                        "text": f"Action item from: {meeting_title}\n\nOwner: {action_item['owner']}"
                    }]
                }]
            },
            "issuetype": {"name": "Task"},
            "priority": {"name": action_item["priority"].title()},
            "assignee": {"accountId": get_jira_user_id(action_item["owner"])}
        }
    }
    if action_item["deadline"] != "TBD":
        payload["fields"]["duedate"] = action_item["deadline"]

    response = requests.post(
        f"{JIRA_URL}/rest/api/3/issue",
        json=payload,
        auth=(JIRA_USER_EMAIL, JIRA_API_TOKEN)
    )
    return response.json()["key"]  # Returns "SPRINT-142"

Slack Distribution

Post the meeting summary and action item list to the relevant Slack channel automatically. Use Slack's Block Kit for structured formatting — it renders action items as a checklist that participants can see immediately after the meeting ends. Tag the assignees so they receive a notification. Include a link to the full summary document for anyone who wants the details.

import slack_sdk

slack = slack_sdk.WebClient(token=SLACK_BOT_TOKEN)

def post_meeting_summary(channel: str, summary: dict, jira_tickets: list[str]) -> None:
    blocks = [
        {"type": "header", "text": {"type": "plain_text", "text": f"📋 {summary['title']}"}},
        {"type": "section", "text": {"type": "mrkdwn", "text": summary["executive_summary"]}},
        {"type": "divider"},
        {"type": "section", "text": {"type": "mrkdwn", "text": "*Action Items:*"}},
    ]

    for i, (item, ticket) in enumerate(zip(summary["action_items"], jira_tickets)):
        priority_emoji = "🔴" if item["priority"] == "HIGH" else "🟡" if item["priority"] == "MEDIUM" else "🟢"
        blocks.append({
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": f"{priority_emoji} *{item['owner']}* — {item['task']} _(due: {item['deadline']})_ <{JIRA_URL}/browse/{ticket}|{ticket}>"
            }
        })

    slack.chat_postMessage(channel=channel, blocks=blocks)

CRM Integration for Client Meetings

For sales calls and client meetings, push summaries and action items directly into Salesforce or HubSpot as activity records linked to the account. This turns every client conversation into a CRM entry without requiring your reps to manually log anything. If you're already integrating Claude with Salesforce, you can extend the same MCP server to handle meeting logging. For AI agent-based approaches to CRM automation, see our guide on Claude AI agents that book meetings and manage tasks.

Step 5: Advanced Patterns

Meeting Series Intelligence

Once you have structured summaries stored for multiple meetings, you can ask Claude to reason across them. "What action items from the last three sprint reviews are still unresolved?" or "What decisions about the payment service have we made in the last six weeks?" Build this as a separate analytical endpoint that retrieves the last N meeting summaries for a given meeting series and passes them to Claude for synthesis. This is the kind of institutional memory that currently lives only in the heads of senior team members.

Real-Time Summarisation with Claude Cowork

If your organisation deploys Claude Cowork, you can connect a meeting summarisation plugin directly to your Zoom or Teams account via MCP. During the meeting, Cowork can answer questions like "what have we decided so far?" or "what did Sarah commit to?" — giving participants real-time context without disrupting the conversation. See our Cowork deployment service for details on plugin architecture.

Automated Follow-Up Email Generation

Client-facing meetings often require a follow-up email within 24 hours. Automate this: after a client meeting summary is generated, pass it to Claude with a prompt to draft a follow-up email in your organisation's tone, referencing the decisions made and confirming next steps. Route the draft through a human review queue before sending. This typically cuts post-meeting email drafting time from 20 minutes to 2 minutes of review. For a complete guide to AI-driven post-meeting workflows, see our agent tutorial series.

Step 6: Cost Optimisation with Prompt Caching

If you run the same system prompt on hundreds of meeting transcripts per week, prompt caching can cut your Claude API costs by 50–70%. Mark your system prompt as a cache breakpoint — Anthropic stores it server-side and bills at a 90% discount on cache hits. For a 500-person organisation processing 200 meetings per week, this optimisation alone can save $3,000–8,000/month depending on average meeting length.

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=2048,
    system=[
        {
            "type": "text",
            "text": SUMMARISATION_SYSTEM,
            "cache_control": {"type": "ephemeral"}  # Cache this prompt block
        }
    ],
    messages=[{"role": "user", "content": transcript_with_metadata}]
)

Data Privacy and Retention

Meeting transcripts contain sensitive information: personnel discussions, client negotiation details, financial projections, and personal conversations. Before deploying this system, establish clear data governance rules. Define which meeting types are eligible for automated processing (opt-in vs default-on), how long raw transcripts and summaries are retained, who can search the summary archive, and whether transcripts are ever sent to Anthropic. Under Claude's enterprise API terms, your data is not used for training, but document this explicitly in your internal AI governance policy.

For regulated industries — financial services, healthcare, legal — apply additional controls: encrypt transcripts at rest, restrict summary access by data classification, and maintain an audit log of who accessed which meeting summaries. See our guide on Claude in regulated industries and our Claude Security & Governance service for enterprise-grade controls.

If you're ready to deploy a meeting summarisation system across your organisation and want expert architecture guidance, book a free strategy call with our team. We've shipped these pipelines for consulting firms, financial institutions, and engineering organisations, and we know exactly where the implementation pitfalls are.