Meetings Produce Information. Most of It Evaporates.
I sat in a client call last month where we agreed on three specific deliverables, a revised timeline, and a budget adjustment. Everyone nodded. Everyone agreed. Three days later, nobody could remember the exact numbers or who owned what. I had to dig through a transcript to reconstruct the meeting.
This happens constantly. Meetings generate decisions, action items, and commitments at a rate that exceeds human note-taking capacity. Even when someone takes notes, the notes are incomplete, biased toward what the note-taker found interesting, and almost never get distributed in an actionable format. The transcript exists – most meetings are recorded now – but a 45-minute transcript is a 6,000-word wall of text that nobody will read.
MP-04 solves this. It’s the fourth agent in my autonomous fleet, and its job is simple: take any meeting transcript, extract everything actionable, and route it to the right systems before the meeting fades from memory.
What MP-04 Extracts
The agent processes meeting transcripts through Ollama’s Llama 3.2 model with a structured extraction prompt. It pulls five categories of information:
Action items: Anything that someone committed to doing. “I’ll send the proposal by Friday” becomes an action item assigned to the speaker with a Friday deadline. “We need to update the website copy” becomes an action item with no assignee – flagged for me to assign. The model distinguishes between firm commitments (someone said “I will”) and vague suggestions (“we should probably”) and tags them accordingly.
Decisions: Any point where the group reached agreement. “Let’s go with Option B” is a decision. “The budget is ,000” is a decision. These get logged as immutable records – what was decided, when, and by whom. Decisions are critical for accountability. When someone later says “we never agreed to that,” the decision log settles it.
Client mentions: Names of clients, companies, or projects discussed. Each mention gets cross-referenced against my client database to attach the meeting context to the right client record. If a client was discussed in three meetings this month, their record shows all three with relevant excerpts.
Deadlines and dates: Any temporal commitment. “The launch is March 15th.” “We need this by end of quarter.” “Let’s review next Tuesday.” These get extracted with enough context to create calendar-ready events or task due dates.
Open questions: Things raised but not resolved. “What’s the pricing for the enterprise tier?” with no answer in the transcript becomes an open question flagged for follow-up. These are the items that silently disappear after meetings if nobody tracks them.
The Routing Layer
Extraction is useful. Routing is what makes it operational.
After extracting the five categories, MP-04 routes each item to the appropriate system:
Action items become Notion tasks in my Tasks Database. Each task is pre-populated with the company (inferred from client mentions), priority (inferred from deadline proximity and language urgency), source (the meeting date and title), and a link back to the full transcript. I don’t create these tasks manually. They appear in my task board, ready to be triaged in my next planning session.
Decisions get logged to the Knowledge Database in Notion. This creates a searchable decision history. Three months from now, when I need to recall what was agreed about the Q2 content strategy, I search the decisions log instead of scrubbing through transcripts.
Client mentions update the Client Database with a meeting note. The note includes a 2-3 sentence summary of what was discussed about that client, automatically generated from the relevant transcript sections.
Deadlines get posted to Slack with a reminder. If the deadline is within 7 days, it goes to my priority channel. If it’s further out, it goes to the weekly planning channel.
Open questions become follow-up tasks in Notion, tagged with a “needs-answer” status that keeps them visible until resolved.
The Technical Reality
MP-04 runs locally on my Windows machine. The input is a text transcript – either pasted directly or loaded from a file. Most meeting platforms (Zoom, Google Meet, Teams) now generate transcripts automatically, so the input is free.
The Ollama call uses a detailed system prompt that defines the extraction schema with examples. The prompt is about 800 tokens of instructions that tell the model exactly how to format each extracted item – as JSON objects with specific fields for each category. This structured output means the routing script can parse the results programmatically without any ambiguity.
Processing time for a 45-minute meeting transcript (approximately 6,000 words): about 15 seconds on Llama 3.2 3B running locally. The Notion API calls to create tasks, update client records, and log decisions add another 5-10 seconds. Total time from transcript to fully routed outputs: under 30 seconds.
Compare that to the manual process: read the transcript (15 minutes), identify action items (10 minutes), create tasks in Notion (5 minutes), update client records (5 minutes), set reminders for deadlines (5 minutes). That’s 40 minutes of administrative work per meeting, reduced to 30 seconds.
The Client Name Guardrail Problem
One unexpected challenge: client names in transcripts are messy. People use first names, company names, project codenames, and abbreviations interchangeably. “The Beverly project” and “a luxury lending firm” and “Sarah’s account” might all refer to the same client.
I built a name resolution layer that maps common references to canonical client records. It’s a JSON lookup table: “Beverly” maps to “a luxury lending firm Company,” “Sarah” maps to “Sarah [Client Last Name] at a luxury lending firm,” “BL” maps to “a luxury lending firm.” The table has about 150 entries covering all active clients and common reference patterns.
When the extraction model identifies a client mention, the name resolver checks it against this table before routing. If there’s no match, it flags the mention as “unresolved client reference” for manual review rather than creating a misattributed record. The guardrail prevents the worst outcome – action items attached to the wrong client – at the cost of occasionally requiring a 10-second manual resolution.
What Changed After 60 Days of Running MP-04
The obvious win: I stopped losing action items. In the 60 days before MP-04, I estimate that about 20% of meeting commitments fell through the cracks – not from negligence, but from the gap between hearing a commitment and recording it in a system. In the 60 days after, that dropped to under 3% (the remaining 3% are items the model misclassifies or that I manually deprioritize).
The less obvious win: meeting quality improved. When you know every commitment will be automatically extracted and tracked, you’re more careful about what you commit to. Meetings became more precise. Fewer vague “we should probably” statements, more specific “I will deliver X by Y.” The agent didn’t just capture accountability – it created it.
The unexpected win: the decision log became a strategic asset. Having a searchable history of every decision across every client turned out to be invaluable for quarterly reviews, contract renewals, and scope discussions. “Based on the decisions log, we’ve expanded scope three times without adjusting the retainer” is a powerful conversation to have with data behind it.
Frequently Asked Questions
What meeting platforms does MP-04 work with?
Any platform that produces a text transcript. Zoom, Google Meet, Microsoft Teams, Otter.ai, and Fireflies all export transcripts. MP-04 doesn’t integrate with these platforms directly – it processes the transcript file. This keeps it platform-agnostic and avoids the complexity of OAuth integrations with every meeting tool.
How accurate is the action item extraction?
On my test set of 40 meeting transcripts, the model correctly identified 91% of action items I had manually tagged. The 9% it missed were typically very implicit commitments – things like “I’ll take care of that” without specifying what “that” refers to. It also occasionally generates false positives from hypothetical statements – “if we were to do X, we would need Y” getting tagged as a commitment. The false positive rate is about 5%, easily caught in the triage step.
Can this work for meetings I didn’t attend?
Yes – and that’s one of the most useful applications. Team members can drop a transcript into the processing queue and I get a structured summary with action items without having attended the meeting. This is especially valuable for the meetings I delegate but still need to track outcomes from.
What about sensitive meeting content?
Everything runs locally. The transcript is processed by Ollama on my machine, routed to my private Notion workspace, and posted to my private Slack channels. No third-party service sees the meeting content. This is critical for client meetings that discuss financials, legal issues, or strategic plans.
The Agent Philosophy
MP-04 embodies the principle that runs through my entire agent fleet: don’t automate decisions – automate the administrative overhead around decisions. The agent doesn’t decide what to prioritize or how to respond to a client request. It extracts the raw information, structures it, and routes it to where I can make those decisions quickly and with full context. The human judgment stays human. The administrative busywork disappears.
Leave a Reply