Meeting notes to action items to calendar automation

Introduction

You've just finished a ninety-minute strategy meeting. Three different people spoke. Action items were scattered across the conversation like breadcrumbs. Someone mentions a deadline. Another person says they'll "handle the follow-up". Two days later, nobody knows what actually got assigned to whom, and nothing has been blocked on anyone's calendar.

This is the meeting tax. Organisations pay it constantly. The meeting itself generates work, but extracting that work and turning it into something trackable requires another manual task. Someone has to listen back to the recording, write up notes, identify action items, figure out who owns what, and then manually add those tasks to various systems. Even if you're diligent about it, you're looking at twenty to thirty minutes of administrative work per hour of meetings.

Here's the thing: this workflow can be completely automated. A recording gets transcribed, action items get identified, tasks get created with owners assigned, and time gets blocked on calendars, all without anyone touching a keyboard after the meeting ends. This Alchemy shows you how to build that automation with three focused tools and one of four orchestration platforms.

The Automated Workflow

We're going to connect three tools in sequence: MeetGeek for recording and initial transcription, the productivity app for creating tasks with AI-generated action items, and Reclaim.ai for intelligent calendar management. The orchestration happens through Zapier, n8n, Make, or Claude Code, depending on your comfort level and existing infrastructure.

High-level flow:

1. Meeting ends in your calendar application.

2. MeetGeek records, transcribes, and extracts key points.

3. Orchestration tool detects transcription completion.

4. Action items are generated via AI and created as tasks in your productivity app.

5. Each task is mapped to an owner.

6. Reclaim.ai claims calendar time for task completion based on task duration estimates.

7. Notifications go out to assignees.

Let's walk through each step with real configuration.

Setting Up MeetGeek

MeetGeek works by integrating with your calendar application (Google Calendar, Outlook, or Zoom). When a meeting ends, it automatically uploads the recording and transcription to its servers. The transcription is available within minutes, usually five to fifteen depending on length.

For this automation to work, you need MeetGeek to send a webhook when transcription is complete. MeetGeek's webhook payload looks like this:

Copy{
  "event": "transcription_completed",
  "meeting_id": "meeting_12345",
  "title": "Q4 Strategy Planning",
  "transcript": "full transcript text here...",
  "summary": "discussed roadmap priorities, budget allocation, timeline",
  "created_at": "2024-01-15T14:30:00Z",
  "attendees": [
    {
      "email": "alice@company.com",
      "name": "Alice Chen"
    },
    {
      "email": "bob@company.com",
      "name": "Bob Martinez"
    }
  ],
  "duration_minutes": 60
}

You'll need to configure this webhook in MeetGeek's settings. Go to Integrations, find Webhooks, and point it to your orchestration tool's webhook endpoint.

Orchestration Layer:

Choosing Your Tool

Zapier is the most approachable if you've never built an automation before. It has a visual interface and MeetGeek, the productivity app, and Reclaim.ai all have native Zapier integrations.

n8n gives you more control and runs on your own infrastructure if you prefer. It's free to self-host, though it requires some technical setup.

Make (Integromat) sits in the middle. Good visual builder, strong webhook support, good pricing for moderate volume.

Claude Code is the wildcard option. If you're comfortable with Python or JavaScript, you can write the entire orchestration directly and run it via a serverless function triggered by the webhook.

For this walkthrough, I'll show you the n8n approach since it's transparent about what's happening, and then briefly note the Zapier equivalent.

Building the n8n Workflow

Create a new workflow in n8n. Start with a Webhook trigger node that listens for POST requests from MeetGeek.

In the Webhook node, set the path to something like /meetgeek-transcription-ready. Save the full URL; you'll add this to MeetGeek's webhook settings.

Copy
Webhook Node Settings:
- HTTP Method: POST
- Path: /meetgeek-transcription-ready
- Response Mode: On First Output

Next, add an HTTP Request node to call your productivity app's API. The app needs to create a task, but not just any task; it needs to ask for action items first. This is where the AI comes in.

Add a node that calls an LLM (you can use OpenAI's API directly, or if your productivity app has built-in AI, use that). The prompt should be:

Copy
Extract all action items from the following meeting transcript.
For each action item, identify:
1. What is the action?
2. Who should own it?
3. How long should it take (estimate in hours)?
4. What is the deadline (if mentioned)?

Format the response as a JSON array with fields: action, owner_email, estimated_hours, deadline_date

Transcript:
{{ $node["Webhook"].json["transcript"] }}

Depending on your productivity app, you might have a built-in AI node (like Anthropic Claude or OpenAI). If using OpenAI directly, the node config looks like this:

Copy{
  "method": "POST",
  "url": "https://api.openai.com/v1/chat/completions",
  "headers": {
    "Authorization": "Bearer YOUR_OPENAI_API_KEY",
    "Content-Type": "application/json"
  },
  "body": {
    "model": "gpt-4-turbo",
    "messages": [
      {
        "role": "system",
        "content": "You are a meeting analyst. Extract action items from transcripts."
      },
      {
        "role": "user",
        "content": "Extract action items: [TRANSCRIPT HERE]"
      }
    ],
    "temperature": 0.5
  }
}

Once you have the action items as structured data, add a Loop node to iterate over each action item. Inside the loop, create a task in your productivity app.

Example task creation call (REST API):

Copy
POST /api/v1/tasks
Content-Type: application/json
Authorization: Bearer YOUR_PRODUCTIVITY_APP_TOKEN

{
  "title": "{{ $node["AIExtraction"].json["items"][0]["action"] }}",
  "description": "From meeting: Q4 Strategy Planning\nDeadline: {{ $node["AIExtraction"].json["items"][0]["deadline_date"] }}",
  "assigned_to_email": "{{ $node["AIExtraction"].json["items"][0]["owner_email"] }}",
  "estimated_duration_hours": {{ $node["AIExtraction"].json["items"][0]["estimated_hours"] }},
  "due_date": "{{ $node["AIExtraction"].json["items"][0]["deadline_date"] }}",
  "tags": ["meeting-generated"]
}

Now you have tasks with owners and duration estimates. The next step is calendar blocking. Add another node that calls Reclaim.ai's API.

Reclaim.ai has an endpoint for creating "Schedule Blocks," which reserves time on a person's calendar for a given task.

Copy
POST https://api.reclaim.ai/api/v2/scheduleBlocks
Authorization: Bearer YOUR_RECLAIM_API_KEY
Content-Type: application/json

{
  "title": "{{ $node["TaskCreation"].json["title"] }}",
  "taskId": "{{ $node["TaskCreation"].json["id"] }}",
  "owner": "{{ $node["AIExtraction"].json["items"][0]["owner_email"] }}",
  "duration": {{ $node["AIExtraction"].json["items"][0]["estimated_hours"] * 60 }},
  "eventColor": "blue",
  "isBufferTime": false
}

Reclaim.ai intelligently finds gaps in the assignee's calendar and slots the time there. If no gaps exist, it suggests times or queues the task for later scheduling.

Finally, add a Slack or email notification node to alert assignees. You can use the productivity app's native notification system, or send via webhook if you use Slack:

Copy
POST https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK

{
  "text": "New action item assigned to you",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*{{ $node["AIExtraction"].json["items"][0]["action"] }}*\nOwner: {{ $node["AIExtraction"].json["items"][0]["owner_email"] }}\nEstimated time: {{ $node["AIExtraction"].json["items"][0]["estimated_hours"] }}h"
      }
    }
  ]
}

Save and activate the workflow. Test it by recording a short meeting in MeetGeek.

Zapier Configuration (For Comparison)

If you're using Zapier instead, the steps are simpler but less transparent:

1. Create a Zap with MeetGeek as the trigger (Transcription Completed).

2. Add an action step using Zapier's Built-in Apps for AI to prompt GPT-4 with the transcript.

3. Add another action step to create a task in your productivity app.

4. Use Reclaim.ai's Zapier integration to create calendar blocks.

5. Add email or Slack notification steps.

Zapier handles most of the API authentication for you; you just paste in your API keys once, and Zapier manages them. The downside is less visibility into what's actually being sent and less flexibility if you need custom logic.

Using Claude Code for Full Customisation

If you want maximum control and are comfortable with code, Claude Code (or any similar LLM-powered code generation) can scaffold the entire orchestration in Python:

Copyimport anthropic
import requests
from datetime import datetime

def process_meeting_webhook(webhook_payload):
    """
    Main handler for MeetGeek webhook.
    Receives transcription, extracts action items, creates tasks, blocks calendar time.
    """
    
    client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_KEY")
    
    transcript = webhook_payload["transcript"]
    attendees = webhook_payload["attendees"]
    
    # Step 1: Extract action items using Claude
    extraction_prompt = f"""
    Extract action items from this meeting transcript.
    Return a JSON array with: action, owner_email, estimated_hours, deadline_date
    
    Attendees: {[a["email"] for a in attendees]}
    
    Transcript:
    {transcript}
    """
    
    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": extraction_prompt}
        ]
    )
    
    action_items = parse_json_from_response(message.content[0].text)
    
    # Step 2: Create tasks in productivity app
    for item in action_items:
        task_response = requests.post(
            "https://api.productivity-app.com/v1/tasks",
            headers={
                "Authorization": f"Bearer {PRODUCTIVITY_APP_TOKEN}",
                "Content-Type": "application/json"
            },
            json={
                "title": item["action"],
                "assigned_to_email": item["owner_email"],
                "estimated_duration_hours": item["estimated_hours"],
                "due_date": item["deadline_date"],
                "tags": ["meeting-generated"]
            }
        )
        task_id = task_response.json()["id"]
        
        # Step 3: Block calendar time via Reclaim.ai
        reclaim_response = requests.post(
            "https://api.reclaim.ai/api/v2/scheduleBlocks",
            headers={
                "Authorization": f"Bearer {RECLAIM_API_KEY}",
                "Content-Type": "application/json"
            },
            json={
                "title": item["action"],
                "taskId": task_id,
                "owner": item["owner_email"],
                "duration": int(item["estimated_hours"] * 60),
                "eventColor": "blue"
            }
        )
        
        # Step 4: Send notification
        send_slack_notification(
            item["owner_email"],
            item["action"],
            item["estimated_hours"]
        )
    
    return {"status": "success", "tasks_created": len(action_items)}

def parse_json_from_response(text):
    """Parse JSON from Claude response (handles markdown code blocks)."""
    import json
    import re
    json_match = re.search(r'

```json\n(.*?)\n

```', text, re.DOTALL)
    if json_match:
        return json.loads(json_match.group(1))
    return json.loads(text)

def send_slack_notification(email, action, hours):
    """Send Slack notification to assignee."""
    requests.post(
        "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
        json={
            "text": f"New action item: {action}",
            "blocks": [{
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*{action}*\nEstimated: {hours}h"
                }
            }]
        }
    )

You'd deploy this as a Lambda function, Cloud Function, or local server endpoint, and point MeetGeek's webhook to it. This approach gives you full control over logic, error handling, and customisation.

The Manual Alternative

If you want to keep things simple and maintain human oversight, skip the full automation. Instead, use just MeetGeek + your productivity app. After a meeting, MeetGeek sends you the transcript and summary. You spend five minutes manually reading the summary, creating two or three tasks in your productivity app, and assigning them. Then manually block calendar time in Reclaim.ai for yourself.

This works if you have very few meetings or if meetings generate only one or two follow-up tasks. The manual step keeps you in the loop and lets you reword action items for clarity. If meetings are frequent or generate many tasks, the automation becomes worthwhile because the time savings compound.

Pro Tips

Error Handling and Retries. If MeetGeek's webhook delivery fails, or if the AI extraction returns malformed JSON, your entire workflow breaks. In n8n, add Error Handlers to nodes that might fail. For the AI extraction step, add a Try-Catch equivalent: if Claude doesn't return valid JSON, prompt it again with stricter instructions. Zapier has built-in retry logic for most integrations; Make and n8n let you configure custom retry strategies.

Rate Limits. OpenAI's API has rate limits, and so does your productivity app's task creation endpoint. If you run this automation for multiple meetings simultaneously, you'll hit limits. Space out API calls using n8n's Wait nodes, or use Reclaim.ai's batching capabilities to create multiple tasks in one request if supported.

Cost Optimisation. Claude costs roughly £0.003 per 1,000 input tokens. A typical meeting transcript of 5,000 words costs about £0.015 to extract action items from. If you run this on fifty meetings a month, that's less than £1 in LLM costs. Your productivity app and calendar tool costs dwarf the orchestration cost.

Handling Ambiguous Owners. If a meeting transcript says "we need to do X", the AI might not know who owns it. Add a fallback: if the AI can't determine an owner, create the task but assign it to the meeting organiser with a note that ownership needs clarification. Alternatively, use the productivity app's nested AI chat to ask for clarification in real time.

Testing the Workflow. Before running this on real meetings, test with a recorded meeting transcript you have on hand. Paste it into your orchestration tool and manually trigger the workflow. Review the tasks created and calendar blocks suggested before letting it run automatically.

Cost Breakdown

Cost varies by team size and meeting volume. If you self-host n8n and use Claude API, you're at the lower end. Using Zapier with all paid integrations pushes you higher.