How to Turn Meeting Recordings into a Summary and Action Items Automatically

How to Turn Meeting Recordings into a Summary and Action Items Automatically

Summary

  • VTT transcripts with speaker labels preserve the timestamps and attribution an LLM needs to assign action items to named owners; plain text and SRT strip that context.
  • Prompt the LLM for strict JSON with timestamped evidence, null for unstated owners and due dates, and an unresolved_ambiguities array; use MapReduce splitting when a transcript exceeds the model's context window.
  • Push the summary to HubSpot Notes, each action item to HubSpot Tasks with an association to the right contact or company, then fan out the same JSON to Notion and Slack.
  • Gate all CRM writes behind a human approval step so a single hallucinated commitment never reaches the record.
  • Jinba Flow lets teams build this meeting-to-CRM pipeline with WAIT_FOR_APPROVAL gates, 100+ integrations, and on-prem governance already in place.

Meeting recordings produce transcripts, transcripts produce summaries, and summaries sit in inboxes, where most pipelines stop and value is lost. The gap is the step between a summary existing and a task appearing in HubSpot, Notion, or a Slack channel with an owner and a due date. For sales teams, the operational bottleneck is the handoff of meeting notes into the CRM, which is a separate problem from recording capture.

This guide covers the complete four-step pipeline: extracting a clean transcript, using an LLM to produce structured JSON output, pushing that output to the tools operations teams already use, and building in a human review step before anything reaches the CRM. Each step is specific enough to implement directly.

Step 1: Get a Clean, Speaker-Labeled Transcript

The quality of every downstream step depends on the transcript. A plain-text transcript with no speaker labels produces ambiguous action items. Zoom Cloud Recordings address both problems: they generate an audio transcript automatically, and they output it as a VTT file.

VTT is the right format for this pipeline. It requires a WEBVTT header, uses a dot separator for milliseconds (HH:MM:SS.MS), and supports speaker tags using <v Speaker Name>text</v> inline markup. Speaker attribution makes it possible to assign an action item to a named owner later. SRT, by contrast, uses no header, comma-separated milliseconds, and carries no speaker information at all.

Organizations using a third-party transcription service such as Otter.ai, Rev, or Descript should confirm which formats the service exports before committing. Some services export only .txt, which removes speaker labels and timestamps entirely.

One additional factor matters for regulated industries: vendor data practices vary significantly. Otter.ai and Fathom train on de-identified customer data by default. Circleback and Jamie state they do not. A federal court has held that Otter.ai's data handling could classify it as a "third-party eavesdropper" under California law. Most tools capture audio on-device but send it to the cloud for processing, so on-device claims warrant scrutiny. For enterprises in banking or insurance, these distinctions are material.

Step 2: Use an LLM to Extract Structured JSON

A transcript passed to an LLM with a vague prompt returns a paragraph summary. That is not actionable. The goal is structured JSON that a downstream system can parse and act on directly, field by field.

The most effective AI tool for meeting notes extraction is one prompted correctly. Both ANTHROPIC_INVOKE_WITH_FILE and OPENAI_INVOKE support this pattern. The model receives the transcript and a prompt that instructs it to return a strict JSON object. This published prompt from Inocta provides a practical starting template; the schema below reflects its structure with additions for reliability:

{
"summary": "A brief overview of the meeting.",
"decisions": [
{ "decision": "...", "evidence": "[timestamp] direct quote..." }
],
"action_items": [
{
"task": "Specific action to be taken.",
"owner": "Person's Name or null",
"due_date": "YYYY-MM-DD or null",
"priority": "High / Medium / Low",
"status": "Not Started",
"evidence": "[timestamp] direct quote from transcript..."
}
],
"unresolved_ambiguities": [
"A point that requires clarification before a task can be created."
],
"follow_up_message": "A concise 5-8 line message formatted for Slack or Teams."
}

Three prompt rules make the conversion from meeting recording to summary action items reliable:

  1. Never invent owners or due dates. If a name or date is not explicitly stated in the transcript, the field value must be null. This prevents the model from guessing.
  2. Only classify something as a decision if there is explicit agreement language. Phrases such as "we agreed" or "we agree to approve that" qualify. Speculative discussion does not.
  3. Always include an evidence field with a timestamped direct quote. This allows a human reviewer to verify each extraction against the original recording in under ten seconds.

The unresolved_ambiguities array is equally important. It captures anything the model flags as unclear, creating a review queue before an incorrect task is created.

Handling Long Transcripts

A 60-minute meeting transcript routinely exceeds the context window of most models. Passing the full text as a single request causes the model to compress or skip later portions of the meeting without indication.

The correct approach is MapReduce:

  1. Split the transcript into chunks that fit within the model's context window, ideally at natural breaks such as speaker turns or silences.
  2. Map: Run the extraction prompt on each chunk independently, producing a JSON output per chunk.
  3. Reduce: Pass all chunk outputs to a final combining prompt that merges them into a single cohesive summary and de-duplicated action item list.

This preserves extraction fidelity across the full transcript, including the second half of the meeting.

Step 3: Push the Output to Your Tools

The structured JSON output is designed for fan-out: one extraction run updates multiple destinations simultaneously, each formatted for its target system.

HubSpot

A meeting summary and an action item are distinct objects in HubSpot, and the pipeline should treat them as such.

  • Summary: Use HUBSPOT_CREATE_NOTE to create a Note on the relevant contact or company record. Populate the note body with the summary field from the JSON.
  • Action items: Loop through the action_items array. For each item, call HUBSPOT_CREATE_TASK. The HubSpot Tasks API is an engagement API object. When creating each task, populate the subject with the task field, set the due date from due_date, assign the priority, and use the associations object to link the task to the correct contact or company record. Without the association, the task is orphaned in the CRM and provides no operational value.

Notion

Use NOTION_CREATE_DATABASE_ITEM to create a new entry in a Meetings database. Map the JSON fields to the database properties: summary to a text block, decisions to a bulleted list, and action_items to a checklist or a related Tasks database. This produces a permanent, searchable record of every meeting.

Slack

The follow_up_message field in the JSON is pre-formatted as a concise team update. Post it directly to the relevant channel using a Slack integration. This surfaces the key decisions and tasks for team members who were not in the meeting, without requiring them to read a full transcript.

Step 4: Add a Human Approval Step Before the CRM Write

Fully automated pipelines that write directly to the CRM without review reduce trust in the system. A single AI misinterpretation that creates a task with the wrong owner or a fabricated commitment damages the reliability of the entire system.

The prompt design above creates a checkpoint. Any action_item with a null owner or null due_date, and anything in unresolved_ambiguities, is a signal that human review is needed before that record is created.

Formalising this as an approval step is straightforward in Jinba Flow using the WAIT_FOR_APPROVAL node. After the AI extraction step and before the HubSpot write, the node pauses the workflow and sends a notification, typically via Slack or email, presenting the extracted summary and task list. The notification includes Approve and Reject controls. Only on approval does the workflow proceed to HUBSPOT_CREATE_NOTE and the HUBSPOT_CREATE_TASK loop. This prevents hallucinated commitments from appearing in the CRM while still automating the majority of the work.

Maintaining This in Production

The pipeline works; maintaining it at scale is a separate operational problem.

Chunking logic requires updating as model context windows change. Prompts require versioning when model behaviour shifts between releases. API error handling must account for rate limits, partial failures, and malformed JSON responses. For enterprises in regulated industries, every component also needs to pass a security and compliance review before it touches customer data.

These are operational costs that a self-built system carries over time, and they are worth accounting for before committing to a maintenance stance.

Jinba Flow is built for enterprises, specifically banking and insurance, that need this capability with governance already in place. It runs 80% of workflow execution as deterministic, rule-based logic, which keeps costs at $5-20 per month at scale rather than the $300+ typical of fully stochastic AI agents. It supports over 100 integrations, publishes workflows as APIs or batch processes, and ships with on-premises deployment, SOC II compliance, RBAC, SSO, audit logging, and version control. The meeting recording to summary action items pipeline described in this guide is the kind of reusable workflow Jinba Flow is built to host, test, and deploy safely.

For teams that want a conversational layer on top, Jinba App Neo provides governed, shared Claude agents for a team. App Neo is built natively on Anthropic's Claude, with Claude Sonnet 5.5 as the default for most extraction tasks and Claude Opus 5.5 available for complex, long-running reasoning work. Jinba Flow workflows can be called as tools directly from within App Neo agents, which means the full CRM automation pipeline sits behind a simple agent interface without sacrificing the deterministic reliability of the underlying workflow.

App Neo also supports Notion and Slack as personal connectors, making it straightforward to surface meeting summaries and action items across both destinations without additional integration work.

Where to Start

Start with a single meeting type: a recurring sales call or a weekly team standup. Build the extraction prompt, validate the JSON output against five real transcripts, and check the unresolved_ambiguities field to understand where the model needs tighter instructions. Once extraction is reliable, add the HubSpot write. Then add the approval gate. Then fan out to Slack and Notion.

The goal is a pipeline where a meeting ends, a structured record appears in the CRM, tasks are assigned to named owners, and the team receives a Slack update, without manual transcription, copying, or note follow-up. That pipeline is buildable today with the tools described here.

Frequently Asked Questions

How do I automatically send meeting notes and action items to HubSpot?

A four-step pipeline is required: generate a speaker-labeled transcript, have an LLM extract structured JSON, push the summary and tasks into HubSpot through the Notes and Tasks APIs, and insert a human approval gate before anything writes to the CRM. The difficult component is the second step, converting a transcript into fields a CRM can parse; once the LLM returns a fixed schema, the HubSpot calls become mechanical. Each summary becomes a Note on the contact record, and each action item becomes a Task with the subject, due date, priority, and an association back to the same contact or company. Without that association, tasks are orphaned and the pipeline delivers no operational value.

What is the best transcript format for AI meeting notes extraction?

VTT is the best format because it is the only common export that preserves both timestamps and speaker attribution in a machine-parseable structure. A VTT file carries a WEBVTT header, uses a dot separator for milliseconds, and marks speakers inline with <v Speaker Name>text</v>. Speaker tags allow the model to assign an action item to a named owner with attribution from the transcript. SRT has no header, uses comma-separated milliseconds, and carries no speaker information at all, while plain .txt exports remove both timestamps and speakers. For Otter.ai, Rev, or Descript, export options should be confirmed before committing, because some services offer only .txt.

What fields should a meeting notes JSON schema include?

At minimum, six fields: summary, decisions, action_items, unresolved_ambiguities, follow_up_message, and an evidence field on every decision and action item. The action_items array should give each item a task, owner, due_date, priority, status, and a timestamped direct quote as evidence. decisions should be its own array, restricted to items with explicit agreement language. The two fields most teams skip are the ones that matter most in production: unresolved_ambiguities, which is a natural review queue, and evidence, which allows a human to verify any extraction against the original recording in under ten seconds.

Why should an AI not write meeting action items directly into the CRM?

A single misinterpretation, such as a task with the wrong owner or a fabricated commitment, damages trust in the entire system faster than the time the automation saves. Fully automated CRM writes can fail without detection: a hallucinated task may go unnoticed until a customer or sales representative is affected. The solution is to keep automation and add a gate. Any action item with a null owner or null due date, and anything in the unresolved_ambiguities array, is an explicit signal that a human should review the record before it is created. In Jinba Flow this is a single WAIT_FOR_APPROVAL node placed between the extraction step and the HubSpot write. The node pauses the workflow, sends the summary and task list to Slack or email with Approve and Reject controls, and proceeds only on approval.

How do I handle a meeting transcript that is too long for the LLM context window?

Use MapReduce splitting for transcripts that exceed the context window. A 60-minute meeting transcript routinely exceeds the context window of most models, and when it does, the model compresses or skips the later portions of the meeting without indication, producing output that looks valid while half the discussion is missing. Split the transcript into chunks that fit the window, ideally at natural breaks such as speaker turns or silences; run the extraction prompt on each chunk independently to produce a JSON object per chunk (the Map step); then pass all chunk outputs to a final combining prompt that merges them into one cohesive summary and a de-duplicated action item list (the Reduce step). This preserves extraction fidelity across the entire meeting, including the second half.

How do I stop the AI from inventing task owners and due dates?

Put an explicit instruction in the prompt that any name or date not stated verbatim in the transcript must be returned as null, and enforce it with a timestamped evidence field on every extracted item. Models default to helpfulness: given an ambiguous request, they will infer a plausible owner, and an inferred owner in a CRM is worse than no owner at all. Because the evidence field requires a direct quote, the model has no room to fabricate attribution without producing a quote that a reviewer will immediately see is not in the transcript. Every null should be routed to human review rather than treated as an error to be patched.

Which meeting transcription tools train on customer data?

It varies, and the differences matter most in regulated industries. Otter.ai and Fathom train on de-identified customer data by default, while Circleback and Jamie state that they do not. A federal court has held that Otter.ai's data handling could classify it as a third-party eavesdropper under California law. Most tools capture audio on-device but send it to the cloud for processing, so an "on-device" claim warrants scrutiny before reliance. For teams in banking or insurance, vendor training and retention practices should be confirmed in writing as part of the security review.

How much does it cost to run a meeting-to-CRM pipeline?

Cost depends almost entirely on how much of the workflow is deterministic versus stochastic. An architecture that runs roughly 80% of workflow execution as rule-based logic keeps costs in the range of $5–20 per month at scale, while fully stochastic AI agents that re-reason over every step routinely land at $300 or more. The LLM extraction call is the only non-deterministic step, and MapReduce chunking, fixed JSON schemas, and approval gates all reduce how often that step has to be repeated. Prompt versioning, chunking updates, and API error handling are recurring maintenance costs worth budgeting for before committing.

How long does it take to build this pipeline, and where should I start?

Start narrower than the initial plan suggests: one meeting type, such as a recurring sales call or a weekly standup. Build the extraction prompt, then validate the JSON output against five real transcripts and read the unresolved_ambiguities field to identify where the model needs tighter instructions. Once extraction is reliable, add the HubSpot write, then the approval gate, then fan out to Slack and Notion. Teams that try to launch across every meeting type at once usually stall at the prompt-tuning stage. Self-building the full pipeline takes weeks of iteration; a governed workflow platform compresses that to days because the integration, approval, and compliance layers already exist.

人馬一体のワークフロー構築を体験せよ

エンタープライズ組織を支えるAI基盤

無料で始める