I've been conducting a deep-dive analysis of our team's meeting patterns using the Fireflies.ai API over the last quarter, primarily to correlate self-reported "productive meeting" sentiment with the quantitative metrics the platform provides. While the engagement score and speaker talk ratios are interesting high-level indicators, I found them insufficient for proactively identifying meetings that truly represent a risk to team velocity or morale. Consequently, I've developed an internal analytics tool that applies a weighted, multi-factor algorithm to flag meetings for managerial review. The core premise is that a single low engagement score might be an anomaly, but a pattern of specific metric combinations warrants human inspection.
The tool consumes the Fireflies webhook data (we have it POST to a small Flask service), but the critical logic is in the scoring function. It doesn't just look at the overall engagement score; it creates a composite flagging score based on:
* **Engagement Score Deviation:** Compares the meeting's score against the rolling 10-meeting average for that specific channel or participant list, flagging deviations greater than 2 standard deviations.
* **Monologue Detection:** Calculates the percentage of meeting duration dominated by a single speaker (threshold >70%). This is more nuanced than simple talk-time, as it can identify lectures vs. discussions.
* **Keyword Sentiment Clustering:** Uses the Fireflies-generated keywords and applies a basic sentiment analysis (via a local lexicon) to gauge if the discussed topics are predominantly negative (e.g., "blocker," "delay," "missed deadline").
* **Action Item Dilution:** Flags meetings where the number of action items generated is disproportionately low relative to the meeting length (e.g., a 60-minute meeting yielding only one "follow-up" is a potential signal).
The system then applies the following weighting algorithm to generate a "Review Priority Score" (RPS). We currently run this as a nightly batch process over the day's meetings.
```python
# Simplified scoring logic (pseudo-code)
def calculate_review_priority_score(meeting_data):
# Normalized metrics (0-1 scale, higher = more concerning)
engagement_dev = abs(meeting_data.engagement_score - channel_avg) / channel_std_dev
monologue_ratio = max(0, (meeting_data.top_speaker_pct - 0.5) / 0.2) # Threshold at 50%
negative_keyword_ratio = meeting_data.negative_keywords / total_keywords
action_item_density = 1 - min(1, meeting_data.action_items / (meeting_data.duration_min / 15)) # Expect 1 action/15min
# Weighted composite score
rps = (
(engagement_dev * 0.3) +
(monologue_ratio * 0.25) +
(negative_keyword_ratio * 0.25) +
(action_item_density * 0.2)
)
return rps
```
A meeting with an RPS exceeding 0.65 triggers an automated entry in a dedicated dashboard for our engineering managers, providing the deconstructed scores and links back to the Fireflies transcript. This moves us from reactive "someone felt it was bad" to proactive "this meeting pattern is statistically anomalous." Early results have identified several recurring, low-engagement status meetings that were ripe for restructuring. The main bottleneck is the latency of the Fireflies API when batch-fetching transcripts for deeper analysis; we've had to implement an aggressive caching layer using Redis, keyed by the `meeting_id`, to keep processing times under 5 seconds per meeting. The next iteration will incorporate participant-level historical data to flag individuals who are consistently silent in specific meeting contexts.