Automatic Meeting Notes: How It Works, What the Best Tools Do, and How to Build Your Own

What is automatic meeting note software?

Automatic meeting note software is any tool that joins a meeting, records the audio, converts speech to text, and produces a useful summary — without a human typing notes during the call.

At its best, it means you arrive at a meeting, contribute fully to the conversation, and leave knowing that the notes, action items, and key decisions have already been captured and sent to wherever your team stores them.

At its worst, it means a garbled transcript lands in your inbox and gets immediately archived.

The difference between those two outcomes is almost entirely in how the tool is built.

How automatic meeting notes actually work (the full pipeline)

There are five steps in every automatic meeting notes pipeline, regardless of which tool you use:

Step 1: Bot joins the meeting

A software agent — the "meeting bot" — joins the video call as a participant. It's visible in the participant list. It captures the audio stream from the meeting platform. On Google Meet, it joins using a headless browser that emulates a human participant. On Microsoft Teams, it uses the official Bot Framework. On Zoom, it uses a media recording API.

The quality of this step determines everything downstream. A bot that drops audio packets, gets kicked by the platform, or fails to be admitted in the first place produces garbage output regardless of how good the transcription model is.

Step 2: Audio is captured and sent for transcription

The raw audio from the meeting is sent to a speech recognition model. This step involves codec conversion (WebRTC audio is compressed; transcription models prefer raw PCM or wav), buffering, and delivery to the transcription service.

Step 3: Transcription (speech to text)

The transcription model converts the audio to text. Modern models (Whisper and its descendants, fine-tuned variants) achieve 90–97% word accuracy on clear English meeting audio. Accuracy drops on accented speech, technical jargon, and poor audio quality.

Step 4: Speaker diarization (who said what)

A separate model identifies which parts of the transcript belong to which speaker. This step is technically harder than transcription — it requires identifying voice embeddings and clustering them into speakers. Good diarization produces output like "Alice: ..." and "Bob: ...". Poor diarization produces a transcript where the wrong person is credited with someone else's words.

For a deep dive on how diarization works and why it sometimes fails, see speaker diarization explained.

Step 5: Post-processing (summary, action items, insights)

The raw transcript is passed to an LLM (GPT-4o, Claude, or similar) with a prompt designed to extract useful output: a summary of the meeting, a list of action items, key decisions, next steps, or domain-specific insights (deal signals for sales teams, risk flags for customer success).

This step is where the real product differentiation happens. The transcript is a commodity — any decent API can produce one. The prompt engineering, the output structure, and the integration layer that delivers results to the right place are where value is created.

What separates good automatic meeting notes from bad?

Good: the bot is always admitted

Nothing destroys trust in an automatic notes tool faster than the bot getting stuck in the waiting room. On Google Meet, bots need to be admitted by the host — unless the meeting is set to "allow all." Well-built meeting note tools either educate users about this setting or build UX around the admission flow.

Good: speaker attribution is accurate

A summary that attributes your words to the wrong person is worse than no summary at all. Accurate speaker diarization is the hardest technical problem in this stack, and it's the one most tools handle poorly on calls with three or more participants.

Good: output goes where your team already works

Meeting notes delivered to a "notes inbox" in another app that nobody checks are useless. The best tools send output to Slack, Notion, HubSpot, Salesforce — wherever the team already manages their work. This isn't a nice-to-have; it's the difference between features that get used and features that get forgotten.

Good: privacy controls are explicit

Everyone in the meeting should know the bot is there. The bot should be named clearly. Users should have a per-meeting way to disable recording. And the privacy policy should clearly state what happens to the transcript data.

Bad: one-size-fits-all summaries

A 45-minute product review and a 10-minute daily standup don't need the same summary format. A discovery call with a prospect and a customer health check aren't the same thing. Tools that apply one generic prompt to all meetings produce mediocre output for all of them.

Bad: no webhook or export option

If you can't get the transcript data out of the tool programmatically, you're locked into whatever summaries it produces. Any serious meeting intelligence tool should give you access to the raw transcript.

How to build your own automatic meeting notes pipeline

If you're a developer building a product or automating notes for your own team, here's how to wire up the pipeline using the Gregnote API.

Step 1: Send the bot

const res = await fetch("https://api.gregnote.com/v1/bots", {
  method: "POST",
  headers: { "Authorization": `Bearer ${process.env.GREGNOTE_API_KEY}` },
  body: JSON.stringify({
    meeting_url: meetingUrl,
    bot_name: "Notetaker",
    webhook_url: "https://yourapp.com/hooks/meeting-complete",
    metadata: { meeting_id: meetingId, user_id: userId }
  })
});

Step 2: Handle the webhook

app.post("/hooks/meeting-complete", async (req, res) => {
  verifySignature(req, process.env.GREGNOTE_WEBHOOK_SECRET);
  res.sendStatus(200);

const { event, transcript, metadata } = req.body; if (event !== "meeting.completed") return;

await queue.add("generate-notes", { transcript, metadata }); }); ```

Step 3: Generate structured notes with an LLM

async function generateMeetingNotes(transcript, meetingType = "general") {
  const formatted = transcript.segments
    .map(s => `${s.speaker}: ${s.text}`)
    .join("
");

const prompts = { general: Extract: (1) 3-sentence summary, (2) action items with owner and due date if mentioned, (3) key decisions made. Format as JSON., sales: Extract: (1) deal stage indicators, (2) objections raised, (3) agreed next steps, (4) competitor mentions. Format as JSON., interview: Extract: (1) candidate strengths observed, (2) concerns raised, (3) interviewer recommendation, (4) specific examples given. Format as JSON., };

const result = await openai.chat.completions.create({ model: "gpt-4o", messages: [ { role: "system", content: prompts[meetingType] }, { role: "user", content: formatted } ], response_format: { type: "json_object" } });

return JSON.parse(result.choices[0].message.content); } ```

Step 4: Deliver to where your team works

async function deliverNotes(notes, metadata) {
  // Post to Slack
  await slack.chat.postMessage({
    channel: metadata.slack_channel ?? "#meeting-notes",
    text: `*Meeting Notes* — ${metadata.meeting_title ?? "Untitled"}`,
    blocks: formatNotesAsSlackBlocks(notes)
  });

// Push to Notion if (metadata.notion_page_id) { await notion.blocks.children.append({ block_id: metadata.notion_page_id, children: formatNotesAsNotionBlocks(notes) }); } } ```

How much does it cost to run?

Running your own automatic notes pipeline with Gregnote costs £0.50 per hour of captured audio, plus whatever LLM cost you incur for the summarisation step.

For GPT-4o, a 45-minute meeting transcript (roughly 6,000 tokens input + 500 tokens output) costs approximately £0.03–0.05. Total pipeline cost per meeting: roughly £0.40–0.45 for a typical call.

For a team running 40 meetings per week, that's roughly £17–18/week — well under what you'd pay for most per-seat AI notetaker subscriptions.

Ready-made vs custom-built

If you just want automatic notes for your own team and don't need custom integrations, tools like Otter, Fireflies, or Fathom are perfectly good. They're polished, reliable, and cheap.

If you're building a product, or you need notes delivered in a specific format to a specific system, or you need the raw transcript for downstream processing — build your own pipeline using an API like Gregnote. The control you get over prompts, output format, and delivery destination is worth the engineering investment.

See building meeting intelligence into your SaaS product for a complete guide to the architecture.