Meeting Assistant Agent - Awesome AI Apps

Overview

The Meeting Assistant Agent is a comprehensive workflow system that automates meeting management by transcribing notes, creating Linear tasks, sending Slack notifications, and generating summaries—all using parallel and sequential agent orchestration.

Workflow Orchestration

Sequential + Parallel execution patterns

Multi-Tool Integration

Slack, Linear, and File tools

Automated Tasks

Create Linear tasks from meeting notes

Team Notifications

Send Slack summaries to channels

Architecture Pattern

This agent demonstrates the Parallel Workflow Pattern using Agno’s Workflow and Parallel classes to execute independent tasks simultaneously.

Workflow Structure

from agno.workflow import Step, Workflow
from agno.workflow.parallel import Parallel
from agno.agent import Agent

workflow = Workflow(
    name="Enhanced Meeting Assistant Workflow",
    steps=[
        # Step 1: Sequential - Transcribe meeting notes
        meeting_transcription_task,
        
        # Step 2: Parallel - Create tasks AND send notifications
        Parallel(
            slack_notification_task,
            linear_task,
            name="Notification Tasks",
        ),
        
        # Step 3: Sequential - Generate final summary
        summary_task,
    ],
)

Four Specialized Agents

Meeting Transcription Agent

Reads meeting notes from file and creates clean, structured summary.

Linear Task Agent

Creates actionable tasks in Linear with assignees and deadlines.

Slack Notification Agent

Sends team notifications to Slack channels with key decisions.

Summary Agent

Generates comprehensive meeting summary with all outcomes.

Agent Implementation

Agent 1: Meeting Transcription Agent

from agno.agent import Agent
from agno.tools.file import FileTools
from agno.models.nebius import Nebius

model = Nebius(
    id="moonshotai/Kimi-K2-Instruct",
    api_key=os.getenv("NEBIUS_API_KEY")
)

meeting_task_agent = Agent(
    name="Meeting Transcription Agent",
    tools=[FileTools()],
    model=model,
    instructions="""
        You are a meeting transcription assistant.
        
        Task:
        1. Read meeting notes from {file_path} (read only, don't modify)
        2. Transcribe into clean, readable summary
        3. Capture:
           - Project goals
           - Cost estimates
           - Product tiers
           - Pricing strategy
           - Technical stack
           - Timeline
           - Decisions
           - Assigned tasks with deadlines
        4. Format with clear headings and bullet points
        5. Write summary to ./meeting_summary.md
    """,
    markdown=True,
)

Agent 2: Linear Task Agent

from agno.tools.linear import LinearTools

linear_agent = Agent(
    name="Linear Task Agent",
    model=model,
    tools=[LinearTools(api_key=os.getenv("LINEAR_API_KEY"))],
    instructions="""
        You are a productivity assistant.
        
        Job:
        - Create clear, actionable tasks in Linear based on meeting notes
        - For each action item include:
          * Concise title
          * Detailed description
          * Assignee (if specified)
          * Deadline (if specified)
        - Reference specific decisions and responsibilities
        - Include priorities or deadlines if mentioned
    """,
    markdown=True,
)

Agent 3: Slack Notification Agent

from agno.tools.slack import SlackTools

slack_agent = Agent(
    name="Slack Notification Agent",
    tools=[SlackTools(token=os.getenv("SLACK_BOT_TOKEN"))],
    model=model,
    instructions="""
        You are a communication assistant.
        
        Task:
        Send friendly, informative Slack message to #agent-chat channel.
        
        Include:
        - Key decisions made
        - Assigned tasks with assignees and deadlines
        - Pricing strategy ($10,000 charge, $2,000 build cost)
        - Next steps
        - Use bullet points for clarity
        - Mention upcoming meetings or deadlines
        
        Example format:
        
        Hey team! Here's a quick recap:
        
        🎯 Key Decisions:
        • Pricing set at $10,000
        • Build cost approved for $2,000
        
        📋 Assigned Tasks:
        • Set up repo: Alice (due 2025-09-20)
        • Draft proposal: Bob (due 2025-09-18)
        
        🚴‍♂️ Next Steps:
        • Schedule follow-up meeting
        • Finalize requirements
        
        Tasks are in Linear. Let's keep momentum! 🚀
    """,
)

Agent 4: Summary Agent

summary_agent = Agent(
    name="Meeting Summary Agent",
    model=model,
    instructions="""
        You are a summarization assistant.
        
        Generate concise meeting summary focusing on:
        - Main topics
        - Decisions (pricing: $10,000 charge, $2,000 build cost)
        - Assigned tasks
        - Next steps
        
        Format for easy reading and quick reference.
        
        Example structure:
        
        # 📋 Meeting Summary
        
        ## 🎯 Main Topics
        - Project goals and timeline
        - Pricing strategy
        - Technical stack
        
        ## 💡 Decisions
        | Decision    | Details        |
        |------------|----------------|
        | Pricing     | $10,000 charge |
        | Build Cost  | $2,000         |
        | Tech Stack  | Python, React  |
        
        ## 📝 Assigned Tasks
        | Task          | Assignee | Deadline   |
        |--------------|----------|------------|
        | Set up repo   | Alice    | 2025-09-20 |
        | Draft proposal| Bob      | 2025-09-18 |
        
        ## 🚴‍♂️ Next Steps
        - Schedule follow-up meeting
        - Finalize requirements
        - Confirm pricing with client
        
        _See Slack for quick summary and Linear for tasks._
    """,
    markdown=True,
)

Workflow Steps

Step Definitions

from agno.workflow import Step

# Sequential Step 1: Transcribe meeting
meeting_transcription_task = Step(
    name="Meeting Transcription Task",
    agent=meeting_task_agent,
)

# Parallel Steps: Create tasks + Send notifications
linear_task = Step(
    name="Linear Task",
    agent=linear_agent,
)

slack_notification_task = Step(
    name="Slack Notification Task",
    agent=slack_agent,
)

# Sequential Step 3: Generate summary
summary_task = Step(
    name="Summary Task",
    agent=summary_agent,
)

Workflow Orchestration

from agno.workflow import Workflow
from agno.workflow.parallel import Parallel

workflow = Workflow(
    name="Enhanced Meeting Assistant Workflow",
    steps=[
        # Step 1: Must complete first
        meeting_transcription_task,
        
        # Step 2: Run simultaneously (both use transcription output)
        Parallel(
            slack_notification_task,
            linear_task,
            name="Notification Tasks",
        ),
        
        # Step 3: Waits for both parallel tasks to complete
        summary_task,
    ],
)

Execution Flow

Sequential Execution

# Step 1 completes first
transcription_output = meeting_task_agent.run(input)

# Step 2: Parallel execution (simultaneous)
linear_result = linear_agent.run(transcription_output)  # Thread 1
slack_result = slack_agent.run(transcription_output)    # Thread 2

# Step 3: Waits for both to finish
summary_input = f"""
    Transcription: {transcription_output}
    Linear Tasks: {linear_result}
    Slack Notification: {slack_result}
"""
summary_output = summary_agent.run(summary_input)

Running the Workflow

Command Line
Streamlit App
Programmatic

# main.py
from workflow import workflow

if __name__ == "__main__":
    workflow.print_response(
        "Process meeting notes: summarize, create Linear tasks, "
        "and send Slack notification with key outcomes."
    )

Run with:

python main.py

# app.py
import streamlit as st
from main import workflow

st.title("Meeting Assistant Agent")

# File upload
uploaded_file = st.file_uploader(
    "Upload Meeting Notes",
    type=['txt', 'md']
)

if uploaded_file:
    # Save file
    with open("meeting_notes.txt", "wb") as f:
        f.write(uploaded_file.getvalue())
    
    if st.button("Process Meeting"):
        with st.spinner("Processing..."):
            # Run workflow
            result = workflow.run(
                "Process meeting_notes.txt"
            )
            
            # Display results
            for event in result:
                if hasattr(event, 'content'):
                    st.markdown(event.content)

Run with:

streamlit run app.py

from workflow import workflow
from agno.run.workflow import WorkflowRunEvent

def process_meeting(file_path: str):
    result = workflow.run(
        f"Process meeting notes from {file_path}"
    )
    
    outputs = {
        'transcription': None,
        'linear_tasks': None,
        'slack_notification': None,
        'summary': None
    }
    
    for event in result:
        if isinstance(event, WorkflowRunOutputEvent):
            if 'transcription' in event.step_name.lower():
                outputs['transcription'] = event.output
            elif 'linear' in event.step_name.lower():
                outputs['linear_tasks'] = event.output
            elif 'slack' in event.step_name.lower():
                outputs['slack_notification'] = event.output
            elif 'summary' in event.step_name.lower():
                outputs['summary'] = event.output
    
    return outputs

# Usage
results = process_meeting("./meeting_notes.txt")
print(results['summary'])

Advanced Patterns

Parallel vs Sequential

# ❌ WRONG: Sequential execution (slow)
steps=[
    meeting_transcription_task,
    slack_notification_task,  # Waits for transcription
    linear_task,             # Waits for Slack
    summary_task             # Waits for Linear
]

# ✅ CORRECT: Parallel execution (fast)
steps=[
    meeting_transcription_task,
    Parallel(
        slack_notification_task,  # Runs simultaneously
        linear_task,             # Runs simultaneously
    ),
    summary_task  # Waits for BOTH parallel tasks
]

Tool-Specific Agents

# Each agent gets only the tools it needs

meeting_agent = Agent(
    tools=[FileTools()],  # Only file operations
    ...
)

linear_agent = Agent(
    tools=[LinearTools(...)],  # Only Linear API
    ...
)

slack_agent = Agent(
    tools=[SlackTools(...)],  # Only Slack API
    ...
)

summary_agent = Agent(
    tools=[],  # No external tools needed
    ...
)

File Path Templating

instructions = """
    Read meeting notes from {file_path}.
    Process the content and extract key information.
"""

# Agno automatically replaces {file_path} with actual path
workflow.run("Process meeting notes from ./notes/meeting_2025_01_15.txt")

Configuration

Environment Variables

# .env
NEBIUS_API_KEY=your_nebius_api_key
SLACK_BOT_TOKEN=xoxb-your-slack-bot-token
LINEAR_API_KEY=lin_api_your_linear_key

Model Selection

# All agents use same model for consistency
model = Nebius(
    id="moonshotai/Kimi-K2-Instruct",
    api_key=os.getenv("NEBIUS_API_KEY")
)

# Alternative: Use different models per agent
transcription_model = Nebius(id="fast-model")
analysis_model = Nebius(id="powerful-model")

Slack Channel Configuration

# In Slack agent instructions
instructions = """
    Send message to #agent-chat channel...
"""

# Or make it dynamic
instructions = """
    Send message to {channel} channel...
"""

workflow.run(
    "Process meeting notes",
    channel="#engineering-updates"
)

Use Cases

Meeting Automation

Automate post-meeting workflow for all team meetings

Action Item Tracking

Ensure all decisions become tracked tasks

Team Communication

Keep entire team informed via Slack

Documentation

Generate consistent meeting documentation

Project Structure

meeting_assistant_agent/
├── main.py              # Workflow and agent definitions
├── app.py               # Streamlit web interface
├── meeting_summary.md   # Generated output (created by agent)
├── requirements.txt     # Dependencies
└── .env                # API keys (not committed)

Deep Researcher

Sequential workflow without parallelization

Job Finder

Sequential pipeline with OpenAI Agents SDK

Learn More

Agno Framework

Learn about Agno workflows and agent orchestration

Multi-Agent Patterns

Best practices for multi-agent orchestration

Human-in-the-Loop

Build agents that request human input

Starter Agents

Simple Agents

MCP Agents

Memory Agents

RAG Applications

Advanced Agents

​Overview

Workflow Orchestration

Multi-Tool Integration

Automated Tasks

Team Notifications

​Architecture Pattern

​Workflow Structure

​Four Specialized Agents

​Agent Implementation

​Agent 1: Meeting Transcription Agent

​Agent 2: Linear Task Agent

​Agent 3: Slack Notification Agent

​Agent 4: Summary Agent

​Workflow Steps

​Step Definitions

​Workflow Orchestration

​Execution Flow

​Sequential Execution

​Running the Workflow

​Advanced Patterns

​Parallel vs Sequential

​Tool-Specific Agents

​File Path Templating

​Configuration

​Environment Variables

​Model Selection

​Slack Channel Configuration

​Use Cases

Meeting Automation

Action Item Tracking

Team Communication

Documentation

​Project Structure

​Related Patterns

Deep Researcher

Job Finder

​Learn More

Agno Framework

Multi-Agent Patterns

Human-in-the-Loop

Build docs developers (and LLMs) love

Overview

Architecture Pattern

Workflow Structure

Four Specialized Agents

Agent Implementation

Agent 1: Meeting Transcription Agent

Agent 2: Linear Task Agent

Agent 3: Slack Notification Agent

Agent 4: Summary Agent

Workflow Steps

Step Definitions

Workflow Orchestration

Execution Flow

Sequential Execution

Running the Workflow

Advanced Patterns

Parallel vs Sequential

Tool-Specific Agents

File Path Templating

Configuration

Environment Variables

Model Selection

Slack Channel Configuration

Use Cases

Project Structure

Related Patterns

Learn More