Tiro MCP Best Practices: The Self-Filing Meeting

Every week, our team spends an hour in a meeting. By the time it wraps up, everyone has a clear mental picture of "what needs to happen next week," but the real cost comes afterwards. Those action items scatter across notes, Slack, calendar, and other task tools. A week passes, motivation slowly deteriorates, and the next meeting comes back with "we definitely agreed on this, so why didn't it happen?"

We call this the trailing cost of a meeting. The decision itself takes an hour, but keeping that decision alive for a week costs even more. And the biggest gap lies in in the Context Source layer of AI transformation.

This article documents our team's five-step AI transformation setup, where we overlayed Tiro MCP with a traditional retrospective format (KPT) to eliminate the trailing cost of a meeting.

KPT: A 30-year-old retrospective format

KPT (Keep, Problem, Try) originated in Toyota’s Kaizen movement in the 1980s. The three axes are Keep (what to continue), Problem (what is wrong), and Try (what to attempt). Its strength is simplicity, and it has been adapted and reused for over 30 years. Korean startups often run a variant: Keep / Stop / Continue / Start, and our team is no exception.

The strength of KPT is clear: when the meeting ends, everyone leaves with the same structured view of "what to do next week."

However, the weakness is just as clear: KPT defines decisions, not execution. It doesn’t specify where those decisions should go. So intent is lost, and the next KPT starts with rehashing last week’s unfinished actions.

Viewed through the 5-Layer frame from the first article, meeting records belong to the Context Source layer, and it’s this layer that contains the biggest gap in most organizations.

From meeting record to LLM-Ready Data

In a previous article, we defined Conversation Intelligence: turning meeting data into a format AI can use – what we call LLM-Ready Data.

For KPT, this matters because the moment a meeting record becomes LLM-Ready Data, its trailing cost becomes automatable. Instead of humans re-reading notes, extracting actions, and copying them into task tools, an agent can do it.

But conversion alone isn’t enough. The next challenge is connecting that data to the agent.

Enter Tiro MCP

As covered in the previous article, Tiro supports four integration modes: API, MCP, CLI, and Skill. For KPT automation, MCP is the key.

Tiro MCP exposes meeting records, summaries, and speaker-separated transcripts so an LLM can pull them directly. It includes fourteen tools across six areas: Authentication, Notes Discovery, Notes Retrieval, Templates, Share Links, and Folders.

The meeting record in this setup stays lightweight. Action items can be identified from summaries or speaker-level notes – there’s no need to process the entire hour-long transcript. This is the type of multi-turn reasoning territory that MCP excels in, making it possible to classify and act on decisions without flooding the context window with unnecessary detail.

The other tools in the setup follow the same principle. Slack is the Context Source for team channels, and Linear is the issue tracker that contains team tasks. Together with Tiro, these three MCPs form the backbone of this setup.

The five-step setup

The KPT meeting itself remains unchanged. Four Claude Skills are formed to facilitate it.

[1] Pre-meeting collection -> [2] KPT meeting -> [3] Post-meeting classification (Tiro MCP)
                                                       |
                                                       v
                                              [4] Auto-sync to Linear
                                                       |
                                                       v
                                              [5] Daily Slack push
                                                       |
                                                       +-> (back to [1])

Each Skill in order:

Step 1. Pre-meeting collection

Right before the meeting, /kpt-before summarizes Linear issues and Slack activity since the last KPT into a presentation-ready table.

~/.claude/skills/kpt-before.md

description: Right before Tuesday's KPT, summarize Linear/Slack state from the last KPT to now into a presentation table.

1. Set window: last Tuesday 18:00 to now

2. Linear: split assignee=self issues into Done / In progress / Blocked

3. Slack: scan the #biz channel and DMs end to end, classify into 4 categories (action / decision / metric / request)

4. Output the table with 4 sections

Result: the 30 minutes usually spent preparing slides disappear. People are still in charge of decisions, but the collection process is automated.

Step 2. The KPT meeting

This step is not automated. The value of KPT lies in people reviewing the same material and coming to a consensus. The meeting itself runs more efficiently, though, because everyone comes in with the week’s summary already prepared.

Step 3. Post-meeting classification

Right after the meeting, /kpt-after classifies the Tiro record into four categories, extracts self-owned actions, and syncs them to Linear.

~/.claude/skills/kpt-after.md

description: Right after Tuesday's biz KPT, classify the Tiro meeting record into 4 buckets, extract only actions owned by self, auto-sync to Linear.

1. Use Tiro MCP list_notes to identify the one note where all 5 biz participants are present

2. Load body with get_note_transcript

3. Classify team actions into Keep / Stop / Continue / Start

4. Extract owner=self entries into a table (the "next step" inference is the LLM's job)

5. Auto-invoke the kpt-linear-sync skill

By definition, this is where Conversation Intelligence happens. Verbal meeting data passes through speaker separation, structuring, and metadata attachment, becoming LLM-Ready Data, and flows directly into next week’s tasks.

Step 4. Auto-sync to Linear

~/.claude/skills/kpt-linear-sync.md

description: Auto-reflect kpt-after results into the Linear tiro-ax team.

1. Start: create new issue with save_issue (due and priority extracted from the meeting record)

2. Continue: list_issues to shortlist 3 candidates, compare quotes to pick one, get_issue to check current state before updating

3. Stop: same matching pattern, status=Canceled

4. Keep: no change

Auto-sync occurs automatically after step 3, and follows the procedure: before updating an existing issue, always check its current state. If a teammate happens to have edited the description or changed the priority of a task during the week, a safety check ensures automation never overwrites human edits.

Step 5. Daily Slack push

~/.claude/skills/daily-kpt-push.md

description: Each morning, push 1-3 issues from Linear to focus on as a Slack DM.

1. Sort active Linear issues by due, priority, and overdue weight; pick top 3

2. Extract the "next step" from each issue's description and comments

3. Push to Slack DM as cards

(Runs daily at 9am via cron or Claude Code Schedule)

Each morning, 1–3 prioritized issues are reported as Slack DMs. Limiting to three was deliberate — people can only consciously hold a few priorities per day. The report becomes actionable instead of overwhelming.

What this design shows

The setup shows that productivity gains don’t come from swapping tools.

Only when the feedback loop around the meeting itself is redesigned can the trailing cost of the meetings be minimized. Using AI tools, like asking ChatGPT to summarize meetings, will not reduce costs. The lesson is the same as Paul David's electric motor story from the first article. A tool swap is easy, but redesigning how meeting information travels takes time. Productivity always comes from the latter.

The role of the meeting record has shifted. Not long ago, it was simply a log of past discussions and decisions. In this new setup, it becomes the engine that drives what happens next. The same audio file can yield very different outcomes depending on how it’s transformed and where it’s directed – Tiro MCP turns a passive record into an active artifact that shapes the week ahead.

FAQ

Q. What is MCP?

MCP (Model Context Protocol) is an open standard released by Anthropic in November 2024. It provides a consistent way for AI agents to communicate with external tools and data, built on JSON-RPC. For a deeper dive

Q. How do I use Tiro MCP?

Connect a Tiro-account-bound MCP server to Claude Desktop or Claude Code. Fourteen tools including list_notes, get_note, and get_note_transcript become directly callable on the meeting records and in real-time conversation.  Full specs at api-docs.tiro.ooo.

Q. How does this relate to AI transformation?

In the 5-Layer architecture, meeting records sit in the Context Source layer. Tiro MCP converts meetings into LLM-Ready Data and makes them accessible to agent automation. The five-step setup in this article shows what closing the loop around KPT looks like as an early step toward AI transformation.

Q. Can I apply the same setup to my team?

Yes, even if your meeting format is not KPT. Three things are essential: (1) Meetings must become LLM-Ready Data. (2) The procedure that classifies actions must be explicit as a Skill. (3) The classification has to transfer into your team's task tracker. The feedback loop around the meeting is what matters more than the meeting format.

Get started