Skip to content

Workflow · Productivity

Meeting Notes to Action Items

Turn raw notes or a transcript into decisions, owned action items, open questions, and risks — then push to Linear, Jira, or Slack.

Beginner45–90 minutesStack: Claude, GPT, or Gemini, Google Meet / Zoom / Otter (optional), Slack / Linear API (optional)
MeetingsProductivityAutomationTranscription
Edited by The AIKnowHub team · Editorial team

Problem

Meetings end with scattered notes, vague 'we should' statements, and no owners. Transcription tools dump text but don't assign work. PMs spend 20 minutes after every call rewriting bullets into tickets. Action items slip because they never enter the system of record.

Final output

A structured Markdown summary (Decisions, Action items, Open questions, Risks) plus optional JSON or API calls that create Linear/Jira issues and post a Slack recap to the channel.

Architecture

Raw notes or transcript
  → Clean + segment (optional speaker labels)
  → LLM structured extraction (JSON schema)
  → Human validation (2 min)
  → Markdown recap + task tracker sync
  → Slack post with @mentions for owners

Step-by-step

  1. 01

    Choose input source

    Google Meet transcript, Zoom AI Companion, Otter, Granola, or manual bullets. Consistent speaker labels help owner assignment. Strip boilerplate (small talk, AV checks).

  2. 02

    Define output schema

    Lock fields: decisions[], actions[]{owner, task, due, priority}, open_questions[], risks[]. Use JSON schema mode — same shape every meeting.

  3. 03

    Extraction prompt

    Instruct: only extract what's stated or clearly implied; use 'unassigned' / 'TBD' when unknown; never invent deadlines. Require verbatim quote per action for audit.

  4. 04

    Validate and edit

    Human scans owners and dates — fix before sync. 2 minutes beats wrong Jira assignments.

  5. 05

    Sync to tools

    Post Markdown to Slack; create Linear issues via API for each action; link recap doc in Notion/Docs. Optional: [Gemini](/tools/gemini) Workspace flow for Meet-native notes.

What you'll build

A pipeline that converts meeting notes or a transcript into:

  • Decisions — what the group actually agreed
  • Action items — owner, task, due date, priority
  • Open questions — unresolved threads with suggested owners
  • Risks / blockers — what could derail the work

Then optionally syncs actions to Linear/Jira and posts a Slack recap. The goal isn't a prettier summary — it's fewer dropped commitments.

The gap transcription tools don't close

Otter, Meet, and Zoom give you text. They might even bullet "key takeaways." They rarely:

  • Assign owners correctly when names are implicit ("Sarah's team will handle it")
  • Distinguish decisions from brainstorm ideas
  • Produce tracker-ready tasks with due dates
  • Post to Slack with @mentions

LLM extraction with a locked JSON schema plus a 2-minute human check closes that gap for ~$0.01/meeting.

Architecture

Transcript / notes
  → Clean (strip small talk)
    → LLM extraction (JSON)
      → Ambiguity flags (optional)
        → Human edit
          → Markdown recap + Linear API + Slack

Native shortcuts:

Step 1 — Input

Minimum viable: bullet notes you typed during the call.

Better: auto-transcript with speaker labels.

SourcePros
Google MeetFree transcript on Workspace; pairs with Gemini
Zoom AI CompanionSolid summaries on paid plans
Otter / FirefliesCross-platform, searchable archive
ManualHighest accuracy for decisions, lowest capture

Pre-process:

  • Remove AV check, small talk first 2 minutes
  • Normalize names (JonJonathan Park via attendee list)
  • If transcript is > 20K words, split by agenda section

Step 2 — Schema

Use structured output everywhere — same shape, every meeting:

{
  "decisions": [{ "text": "...", "source_quote": "..." }],
  "actions": [{
    "owner": "Alex Chen",
    "task": "Send pricing draft to legal",
    "due": "2026-06-10",
    "priority": "high",
    "source_quote": "Alex will get legal the pricing draft by Tuesday"
  }],
  "open_questions": [{ "text": "...", "suggested_owner": "unassigned" }],
  "risks": [{ "text": "...", "severity": "medium" }]
}

source_quote is your hallucination alarm — if the quote doesn't exist in the notes, delete the row.

Step 3 — Extract

Run the structured extraction prompt (frontmatter) with:

  • Full notes/transcript
  • Attendee list (critical for owners)
  • Optional meeting type (standup | planning | retro) to tune emphasis

Standup: favor blockers and today's commits.
Planning: favor decisions and dated milestones.
Retro: favor risks and process actions.

Model pick: Gemini Flash or Haiku for daily; Sonnet when the meeting was argumentative or ambiguous.

Step 4 — Validate

Non-negotiable 2-minute checklist:

  • Every action has the right owner (not "the team")
  • Due dates are real or explicitly TBD
  • Decisions aren't duplicated as actions
  • Vague tasks rewritten ("look into API" → "Spike: document rate limits for Partner API")

Run the ambiguity pass prompt when >30% of owners are unassigned.

Step 5 — Sync

Slack recap — format JSON with the Slack prompt; @mention owners.

Linear / Jira — one issue per action:

for (const action of extraction.actions) {
  if (action.owner === "unassigned") continue; // or route to triage
  await linear.createIssue({
    teamId: TEAM,
    title: action.task,
    assigneeId: resolveUser(action.owner),
    dueDate: action.due === "TBD" ? undefined : action.due,
    description: `From meeting ${meetingId}\n\n> ${action.source_quote}`,
  });
}

Doc archive — save transcript + JSON to meetings/2026-06-06-product-sync.md for search.

Meeting-type templates

Daily standup

Extract only:

  • Yesterday done / today doing / blockers
  • Skip decisions unless explicit

Planning / review

Extract:

  • Decisions with alternatives considered
  • Dated actions tied to milestones
  • Open questions blocking estimates

Retro

Extract:

  • Process changes (actions)
  • Risks (systemic, not blame)
  • Decisions to try an experiment next sprint

Privacy and compliance

  • Redact customer names and dollar figures before LLM if policy requires
  • Use enterprise endpoints (Gemini Vertex, ChatGPT Team, Claude Team) for HR/legal
  • Don't store raw audio in unsecured drives — transcript text only
  • Retention policy: delete transcripts after 90 days if compliance demands

Extending

  • Pre-meeting brief — pull open actions from Linear, attach to agenda
  • Follow-up bot — Friday Slack DM listing open actions assigned to you
  • Cross-meeting dedup — hash task text, merge "send legal the draft" across two meetings
  • Email mode — same pipeline for client call notes → AI Email Assistant draft

Operating cost

10 meetings/week × $0.01 ≈ $0.40/month in inference. Even with Otter at $20/month, total cost is trivial vs one forgotten action item delaying a launch.

Pairs well with

  • Gemini + Google Meet for capture
  • NotebookLM for turning a quarter of meeting notes into study/reflection material — different job
  • best AI productivity tools for picker context
  • Linear/Jira as system of record — extraction without sync is where workflows die

Prompt examples

Copy any of these, replace the placeholders, run.

Meeting extraction (structured)

Extract structure from the meeting notes below.

Output JSON only:
{
  "decisions": [{ "text": string, "source_quote": string }],
  "actions": [{
    "owner": string,
    "task": string,
    "due": "YYYY-MM-DD" | "TBD",
    "priority": "high" | "medium" | "low",
    "source_quote": string
  }],
  "open_questions": [{ "text": string, "suggested_owner": string | "unassigned" }],
  "risks": [{ "text": string, "severity": "high" | "medium" | "low" }]
}

Rules:
- owner: person named in notes, else "unassigned"
- due: only if a date was stated; else "TBD"
- source_quote: short verbatim phrase supporting each action/decision
- Do not invent tasks that weren't discussed
- Merge duplicate actions

Attendees (for owner matching):
{{attendees}}

Notes:
{{notes}}

Slack recap formatter

Format this JSON meeting extraction as a Slack message.

Use:
- Bold section headers
- Action items as bullet lines: @owner — task (due)
- Max 400 words
- End with "Open questions" only if non-empty

Map owners to Slack handles:
{{slack_map}}

JSON:
{{json}}

Ambiguity pass

Review these extracted actions. Flag any where:
- Owner is ambiguous between 2+ people
- Task verb is vague ("look into", "sync") without deliverable
- Due date was inferred but not stated

Output: { "flags": [{ "action_index": number, "issue": string, "suggested_fix": string }] }

Actions:
{{actions_json}}

Executive summary (optional)

Write a 3-sentence executive summary of this meeting for leadership.

Include: decision count, top blocker, next milestone date if mentioned.
No jargon. No filler.

Full extraction JSON:
{{json}}

Cost estimate

Line itemApprox. cost
Per meeting (Flash / Haiku, 5K-word transcript)$0.01
Per meeting (Sonnet, messy notes + ambiguity pass)$0.05
Linear API sync (negligible)$0.00
Transcription (Otter / Meet add-on, if used)$0–20/mo
Total per run (approx.)~$0.06

Costs depend on model choice, content length, and how aggressively you cache.

Optimizations

  • Batch weekly staff meetings — same attendees, cached attendee→owner map.
  • Run ambiguity pass only when actions > 5 or owner is "unassigned" > 30%.
  • Template per meeting type (standup vs planning vs retro) — different extraction emphasis.
  • Store raw transcript + JSON for search — builds team memory without another SaaS.
  • Use [Gemini Flash](/tools/gemini) for volume; Sonnet for conflict-heavy planning sessions.

Common mistakes

  • Skipping validation — wrong owner on a ticket is worse than no ticket.
  • Letting the model infer due dates from tone ("soon") — force TBD unless explicit.
  • Pasting confidential client names into consumer chat without enterprise controls.
  • No attendee list — owner assignment becomes guesswork.
  • Treating decisions as actions — decisions get logged, not ticketed.

Frequently asked questions

Our [meeting-notes prompt](/prompts#meeting-notes) is a copy-paste template for one-off use. This workflow adds JSON schema, validation, tracker sync, and automation — the production version teams run after every recurring meeting.