Turn meeting notes into action items and decisions

Why this matters

Action items get lost in the gap between the meeting ended and the work happened. Somebody mentioned they’d own something. Three days later, nobody remembers. Decisions get re-litigated in the next meeting because nobody wrote them down clearly. The meeting was useful in the moment and produced almost nothing afterward.

The fix isn’t better notes: it’s a different kind of output. Raw notes are for the meeting; the team needs a structured handoff: decisions made, action items by owner, things still open. One person could do this manually for every meeting, but they don’t, because it’s tedious and they were also in the meeting. An agent does it in 30 seconds. Today, you build that.

Quick start

1. Sign in: open Auxot in your browser and log in.

2. Open chat with the Admin Agent: click Chat in the left menu, make sure the agent picker reads “Admin Agent.”

3. Build the meeting-synthesis agent: paste this:

   I want a "Meeting Synthesis" agent. When I paste in raw meeting notes or a transcript, it produces a structured output: (1) decisions made, with one-line context for each, (2) action items grouped by owner, with deadlines if mentioned, and (3) unresolved questions or things parked for later. Don't summarize the conversation — extract the structured outcomes.
   

4. Answer the Admin Agent’s questions: what your team’s meeting style is, how you usually phrase action items (“X will do Y by Z”), and what to do with off-topic threads.

5. Test on a real recent meeting: paste in your raw notes from a meeting in the last week. Compare the output to what you actually walked away with.

Done? The agent is in Settings → Agents and selectable from the agent picker. Optional next step: wire it to deliver action items by owner to their Slack DMs, not the whole team channel (Connect Slack to your agents).

The agent can do that?

Meeting synthesis goes wrong in predictable ways: action items without clear owners, decisions without context, summaries that read well but miss the point. These three prompts close those gaps.

1. Have the agent cite where each action item came from in the transcript

Open chat with the meeting-synthesis agent and ask:

For every action item, include a one-line quote from the transcript or notes showing where it was assigned. Format: "Owner: [name] — Action: [what] — Deadline: [when, if mentioned] — From: '[quote]'." This way, if someone disputes that they own something, we can point to the exact moment they said yes.

Why it’s non-obvious: Most action items end up assigned to the wrong person because the agent (or the note-taker) inferred ownership from context that wasn’t explicit. The quote citation forces the agent to find an actual moment of assignment in the source. If it can’t find one, it should flag it as ambiguous instead of guessing, and you decide who actually owns it.

2. Have action items delivered by owner, not by team channel

Once the synthesis agent is reliable, add this:

Don't post action items to a single team channel — they get scrolled past. Instead, format the output so each owner gets only their own action items, in their Slack DM. For decisions and unresolved questions, post once to the team channel (or a meeting-summaries channel). Wire Slack the same way as Connect Slack to your agents in the Auxot tutorials.

Why it’s non-obvious: A meeting summary in #general gets read by nobody and acted on by nobody. Sending each person only their own action items into their DM raises ownership awareness from “maybe somebody else will do it” to “this is sitting in my inbox addressed to me.” Same data, different delivery, dramatically different follow-through.

3. Build a “Decision Log” that records decisions over time

Inverted-usage move. Once the synthesis agent has been running for a few weeks:

Build me a "Decision Log" agent. Its job is to take the "decisions made" output from every meeting synthesis and log it as a searchable record — date, decision, context, and who decided. When I ask "when did we decide X?" or "what did we agree about Y?" it can find the answer. Run automatically after every Meeting Synthesis output.

Why it’s non-obvious: Decisions get re-litigated because nobody can remember when or why they were made (“didn’t we decide this in March?”), and nobody wants to go scroll back through twelve meetings. The decision-log agent turns the synthesis output into an institutional memory the whole team can query. You stop having the same argument twice.

Go deeper

The three outputs and why they’re separate

A useful meeting synthesis has three buckets, not one:

• Decisions: what we agreed to do (or not do). Should never be re-opened without new information.
• Action items: work somebody owns, with a deadline.
• Unresolved: things we discussed but didn’t finish. Either parked for next time or need more information.

The mistake most note-takers make is collapsing these. “We talked about pricing” doesn’t tell you whether you decided something, assigned something, or punted. Forcing the agent to use three buckets means anything ambiguous (a discussion that didn’t reach a decision, an action item without an owner) gets flagged correctly instead of buried.

What to feed the agent

Three reasonable inputs, ranked by accuracy:

1. Verbatim transcript (e.g., from Zoom AI, Otter, or Granola). Most accurate: the agent has every word.
2. Detailed live notes (one person’s notes during the meeting). Decent: depends on the note-taker.
3. A summary somebody else already wrote. Worst: you’re synthesizing a synthesis. The agent will miss things that got summarized away.

If your team isn’t already capturing transcripts, the agent’s accuracy will be capped by your note quality. Either invest in transcription or accept that the synthesis agent is only as good as the human input.

Don’t run it on every meeting

Meetings that don’t produce decisions or action items don’t need synthesis: a 10-minute social check-in, a brainstorm where the goal was just generating ideas, or a 1:1 about feelings rather than work. Running the agent on these produces output nobody reads, which trains the team to ignore the agent’s output in general.

Use it on: weekly team meetings, stakeholder reviews, project kickoffs, and decision-making meetings. Skip: 1:1s, casual catch-ups, or brainstorms where the output is captured separately.

Email delivery for action items

Slack DMs are the default delivery in power move 2, but some teams live in email. The pattern is the same as Slack: each owner gets only their own action items, decisions and unresolved threads go to a shared list. The wiring changes by mailbox.

For Gmail, see Wire Gmail drafts through Google’s official MCP. Google’s official Gmail MCP is free and draft-only by design; the action-item email lands in your Drafts folder for you to send.

For Outlook, see Lock Outlook drafts via a draft-only tool policy. Composio Outlook exposes both draft and send tools, so the tool policy is the load-bearing lock that keeps the agent from sending.

The cross-cutting principle (why the agent should never have a send tool, even for action-item emails to your own team) lives in Keep send_email out of your agent tool policies.

Calendar follow-ups: use the hold-first pattern

Some action items include “book a follow-up” or “schedule a review.” Don’t wire the synthesis agent to send calendar invites directly. The right wiring is the hold-first pattern: the agent creates a host-only HOLD event on your calendar with no attendees and a HOLD: prefix; you promote it to a real invite during normal calendar review. See Use the hold-first pattern for agent calendar events for the full wiring.

Writing synthesis to a doc

Slack DM delivery (power move 2 + Step 4) is the safest default. But if your team prefers documents instead (archive, board review, shared visibility), three doc paths work cleanly with Auxot.

Google Docs. Use Composio Google Docs with the agent’s tool policy locked to create_doc only (exclude update_doc from the policy). Every meeting produces a fresh doc named after the meeting and date. You never get an agent overwriting last week’s synthesis with this week’s, because the agent can’t touch existing docs.

Notion. Use Notion’s official MCP with per-page integration access. In Notion settings, grant the integration access to one specific page (e.g., a “Meeting Synthesis” parent page). The agent can write child pages under that parent and nowhere else. Notion’s integration model enforces the boundary at the workspace level, not just at the tool policy.

Word. Use the offline-file Word MCP. The agent writes a .docx to a folder on your machine; you open the file before sharing. Skip the Microsoft Graph paths (live Word in OneDrive) for meeting synthesis. Those write the live document on the first call with no draft state.

The pattern across all three: never let the agent edit existing meeting docs. Create-only (Google Docs), per-page integration (Notion), or offline file (Word): each makes a wrong write into a recoverable mistake instead of a silent overwrite.

Troubleshooting

• Action items get assigned to the wrong person. The agent is inferring from context. power move 1’s quote citation fixes this: if the agent can’t find an explicit assignment, it should flag instead of guess.
• Decisions are listed as “we discussed X” instead of “we decided Y.” The meeting itself didn’t have a clear decision moment, so the agent has nothing to extract. Tighten the meeting before tightening the agent.
• Output is too long. Most teams want a synthesis under 200 words. Edit the agent’s description: “keep total output under 200 words. Cut anything that didn’t produce a decision, action item, or unresolved thread.”
• Same action items keep appearing across meetings. That’s a signal the action items aren’t getting done, not a bug in the agent. Pair with Set up your Monday morning briefing to show stale action items weekly.

Variations & edge cases

• Free tier: the agent works at all tiers. Multi-team setups (Set up multi-team isolation) might want one synthesis agent per team if meeting styles differ.
• Confidential meetings (board, exec, HR): Auxot can be self-hosted on your own infrastructure (Connect a GPU worker and View and manage your License) so transcripts never leave your environment.
• Multi-language meetings: specify in the agent’s description that it should output in your team’s working language regardless of input language.
• Async / Slack-thread “meetings”: the agent can synthesize a long Slack thread the same way it synthesizes a transcript. Paste the thread, ask for the same three-bucket output.
• When NOT to use this: highly creative meetings where the output isn’t decisions or action items: workshop sessions, brainstorms, or off-sites. Capture the artifacts those produce separately (Miro boards, design files, etc.); the synthesis agent adds noise.

Walkthrough

Step 1: Open chat with the Admin Agent

Click Chat in the left menu. Make sure the agent picker at the top reads “Admin Agent.”

Step 2: Build the meeting-synthesis agent

Paste this:

Build me a "Meeting Synthesis" agent. When I paste in raw meeting notes or a transcript, it produces:

1. Decisions — what we decided, one-line context for each.
2. Action items — grouped by owner, with deadlines if mentioned, with a quote from the transcript showing where they were assigned.
3. Unresolved questions or parked threads — anything we discussed but didn't finish.

Skip casual conversation, off-topic threads, and anything that didn't produce a decision/action/question. Keep output under 200 words total. If an action item has no clear owner in the transcript, flag it as "ambiguous" — don't guess.

Make it ready to use.

The Admin Agent will ask a few clarifying questions: what your team’s meeting style is, what tone for the output (formal or casual), and how you usually phrase deadlines.

Step 3: Test on a real recent meeting

Pick a meeting from the last week where you remember roughly what was decided. Paste your notes (or transcript) into chat with the agent. Verify:

• Did it catch every decision you remember?
• Did it catch every action item, with the right owner?
• Are the quote citations real: does the transcript actually say what the agent quoted?
• Did anything important get left out?

For every miss, update the agent’s description. Common adjustments: “capture decisions even if they’re phrased as ‘I think we should’ — that counts as a decision in our team,” or “deadlines like ‘next week’ should be noted explicitly, not normalized to a date.”

Step 4: (Optional) Wire to Slack delivery

Once the agent is reliable, set up the per-owner DM delivery from power move 2 via Connect Slack to your agents. Each meeting’s synthesis runs and:

• Decisions and unresolved questions go to a #meeting-summaries channel.
• Each action item goes only to its owner’s DM.

This is the move that turns the synthesis agent from “interesting output” to “thing that changes how work gets done.”

Step 5: (Optional) Build the Decision Log

After a few weeks, use power move 3 to wire up the decision-log agent. Pair its weekly digest with your Monday briefing (Set up your Monday morning briefing). When somebody asks “didn’t we decide X?” you can answer in 10 seconds.

What’s next

• → Connect Slack to your agents. Per-owner DM delivery is what turns synthesis into action.
• → Wire Gmail drafts through Google’s official MCP. The canonical wiring when action-item delivery goes through Gmail instead of Slack.
• → Lock Outlook drafts via a draft-only tool policy. The canonical wiring when action-item delivery goes through Outlook instead of Slack.
• → Keep send_email out of your agent tool policies. The structural argument for why the synthesis agent should never have a send tool.
• → Use the hold-first pattern for agent calendar events. The canonical wiring when an action item is “schedule a follow-up.”
• → Screen resumes and draft replies. Another high-volume intake stream where structured scoring is more reliable than gut feel before a human conversation.
• → Build a cross-meeting commitments ledger. When one meeting isn’t enough memory, reconcile rolling minutes against a ledger so commitments that vanished across weeks have an owner-facing row.
• → Run a workflow. Wire the synthesis agent to fire automatically after a meeting transcript lands.
• → Set up your Monday morning briefing. Fold the Decision Tracker’s digest into your briefing.
• → Build an internal Q&A agent for your team. Once decisions are logged, the Q&A agent can answer “what did we decide about X?”

Reference

• Three-bucket output: decisions, action items by owner, and unresolved.
• Quote citations prevent action-item misassignment: if the agent can’t find an explicit assignment, it flags as ambiguous.
• Per-owner delivery beats team-channel delivery every time: DMs raise ownership; channel posts get scrolled past.
• Don’t synthesize every meeting: skip 1:1s, casual catch-ups, and pure brainstorms.
• Vague meetings produce vague output: the synthesis is a signal about the meeting itself, not a bug in the agent.
• See also: Screen resumes and draft replies, Build an internal Q&A agent for your team, Roll up initiative threads into weekly goal check-ins, Create an agent from scratch, Connect Slack to your agents, Set up your Monday morning briefing.