MeetFlow

Inspiration

The average professional spends 31 hours per month in unproductive meetings. But the real cost isn't the meeting itself — it's what happens after. Action items get scribbled on sticky notes and forgotten. Decisions made by consensus evaporate by the next day. Follow-up emails that should take five minutes never get written.

We've all been there: three weeks after a critical planning meeting, someone asks "wait, who was supposed to handle that?" and nobody remembers.

MeetFlow was born from a simple frustration: meetings generate valuable outputs, but the pipeline from discussion to execution is completely broken. We wanted to build a system where the moment a meeting ends, every action item, decision, and follow-up is captured, organized, and ready for execution — with the human always in control.

What It Does

MeetFlow is a multi-agent meeting intelligence platform that closes the gap between what's discussed and what gets done. It operates as an automated pipeline:

1. Upload — Paste your meeting transcript or notes into MeetFlow
2. Analyze — A pipeline of 5 specialized AI agents processes the transcript in seconds:
   • Cleans and structures the raw text
   • Extracts every action item with assignee, deadline, and priority
   • Identifies key decisions made and their context
   • Drafts follow-up emails and Slack messages for stakeholders
3. Review — The human-in-the-loop approval workflow lets you approve, reject, or modify each extracted item individually. Nothing moves forward without your explicit sign-off.
4. Execute — Approved action items are pushed to project management tools. Approved follow-ups are sent to the right people through the right channels.

What makes MeetFlow different from simple summarizers:

• It doesn't just summarize — it structures and acts. Each output is a discrete, actionable object with metadata (assignee, priority, deadline, recipient, channel).
• The human-in-the-loop workflow isn't a checkbox — it's the core UX. Every screen is designed around review and approval, giving you confidence that agents are doing what you actually want.
• Full agent transparency — a real-time timeline shows exactly what each agent did, when, and what data it produced. No black boxes.

How We Built It

Architecture: Orchestrator + Specialists

MeetFlow uses a Director → Specialist agent pattern built entirely on the Airia platform:

Agent	Role	Why It's Separate
Director	Routes incoming requests to the right specialist	Single entry point, clean orchestration
Transcriber	Cleans and formats raw meeting text	Optimized for text processing, uses a fast model
Analyst	Extracts structured data (action items, decisions, follow-ups) as JSON	Needs strong reasoning — uses a more capable model
TaskManager	Creates tasks from approved action items in external tools	Connected to project management tool integrations
Communicator	Drafts professional follow-up emails and Slack messages	Tuned for tone, format, and recipient awareness

This separation isn't arbitrary — each agent has a different optimal model, different system prompt, and different tool connections. The Transcriber runs on a fast, cheap model because it's doing text cleanup. The Analyst needs strong reasoning to correctly attribute action items to the right people. The Communicator needs to match professional tone. Airia's platform makes this multi-model orchestration straightforward.

Cross-System Integration

MeetFlow operates across multiple systems, fulfilling the Active Agents track requirement:

• Input: Meeting transcripts (from any source — Zoom, Google Meet, manual notes)
• Processing: Airia agent pipelines (5 agents across multiple AI models)
• Output: Tasks in project management tools (Jira, Asana, Trello) + messages via Email and Slack
• Data: SQLite for meeting storage, agent logs, and approval state

Frontend: Purpose-Built for Review Workflows

The dashboard isn't a generic admin panel — every component was designed specifically for the meeting-to-action workflow:

• StatusPipeline — A horizontal 5-stage visualization (Upload → Transcribe → Analyze → Review → Complete) with animated transitions showing real-time progress
• Tabbed Detail View — Dedicated tabs for Action Items, Decisions, Follow-ups, and Agent Activity, each with approve/reject controls
• AgentTimeline — A vertical, color-coded timeline showing every agent action with expandable input/output data
• Analysis Overlay — An animated full-screen overlay with cycling status text while agents process

Tech Stack

Layer	Technology
Backend	Python 3.12, FastAPI, Airia Python SDK
Database	SQLite via aiosqlite (async, zero-config)
Frontend	React 18, TypeScript, Vite
Styling	Tailwind CSS, Framer Motion (animations)
State	Zustand (lightweight, no boilerplate)
AI Platform	Airia (5 published agents)

Challenges We Ran Into

Getting consistent structured output from agents. The Analyst agent needs to return valid JSON with specific keys (action_items, decisions, follow_ups), each containing arrays of objects with required fields. Different meeting styles (brainstorms vs. sprint planning vs. client calls) produce very different transcript structures. We iterated heavily on the system prompt and added JSON schema validation with graceful fallbacks.

Making human-in-the-loop feel natural. Early prototypes felt like a chore — approve this, approve that, approve the next thing. We redesigned the approval UX so you can see everything at once, batch-approve with one click, and easily distinguish between items that need attention and items that are straightforward. The status badges and priority indicators make triage fast.

Agent activity visualization. We wanted users to understand why the system produced certain outputs, not just accept them. Building the AgentTimeline with expandable input/output data, color-coded agent badges, and staggered animations was technically challenging but essential for building trust.

Accomplishments We're Proud Of

• End-to-end multi-agent pipeline — From raw transcript to executed tasks in under 60 seconds, with human approval at the critical juncture
• The StatusPipeline component — Visually communicates complex multi-stage processing in an instantly understandable way
• Enterprise-grade UI quality — Dark theme, glass-morphism, smooth animations, responsive layout. This doesn't look like a hackathon project — it looks like a product.
• Zero-config deployment — SQLite means no database setup. One pip install, one npm install, and you're running.
• 5 published Airia agents — Each with tuned system prompts, appropriate model selection, and proper tool connections

What We Learned

• The orchestrator pattern is powerful. Having a Director route to specialists isn't just cleaner architecturally — it lets you optimize each agent independently. Swap models, tune prompts, add tools, all without touching the others.
• Human-in-the-loop is a UX problem, not a technical one. The hard part isn't adding an approve button — it's designing a workflow where reviewing 15 action items feels fast and natural instead of tedious.
• Airia makes multi-agent orchestration accessible. Building 5 separate agents with different models, prompts, and tool connections would be complex from scratch. Airia's visual builder and pipeline system made it straightforward to prototype, test, and publish.
• Transparency builds trust. Showing users exactly what each agent did (via the AgentTimeline) dramatically increases their confidence in the outputs. Black-box AI gets rejected; transparent AI gets adopted.

What's Next for MeetFlow

• Live transcription — Real-time mic input with streaming analysis, so results appear as the meeting happens
• Calendar integration — Auto-detect meetings from Google Calendar / Outlook, pre-populate metadata
• Slack bot — Review and approve action items directly from Slack without opening the dashboard
• Team analytics — Track action item completion rates, meeting efficiency scores, and follow-up response times across your organization
• Meeting templates — Pre-configured agent prompts optimized for standup, sprint planning, 1-on-1, and all-hands meeting formats

Built With

• airia
• fastapi
• python
• react
• tailwindcss