We've been evaluating AI meeting assistants for our engineering teams, and the two finalists were Microsoft Copilot (with Teams Premium) and Read AI. We ran a three-week pilot with both. The core question was: which one delivers reliable, actionable summaries for technical discussions, especially around architecture reviews and post-incident meetings?
Here's a breakdown of our practical findings:
**Transcription & Speaker Attribution**
* **Copilot:** Tight integration with Teams meetings is a win. It handles our hybrid meetings (some in-room, some remote) well and accurately attributes speakers from the roster. The transcript is available almost instantly in the meeting chat.
* **Read AI:** Also very accurate, but its strength is in post-meeting analysis. The "Readiness Score" and talk time analytics sparked some interesting team discussions about meeting efficiency, though this was more of a nice-to-have for us.
**Summary Quality for Technical Content**
This was the deciding factor. Our architecture reviews involve jargon, AWS service names, and decision trees.
* **Copilot summaries** were good for general action items and standard follow-ups. However, they sometimes glossed over technical nuances. For example, a debate about using AWS Lambda Powertools vs. a custom wrapper was summarized as "team discussed logging libraries."
* **Read AI** consistently produced more detailed summaries that captured the "why" behind technical decisions. It better identified conflicting viewpoints and extracted specific references to resources (like a mentioned GitHub repo or an AWS documentation page).
**Integration & Cost**
* **Copilot:** Comes bundled with our existing M365 E5 and Teams Premium. No additional per-seat cost was a major point for finance.
* **Read AI:** Adds another subscription. However, its API and ability to generate different output formats (concise, detailed, bullet-point) meant we could potentially automate summary distribution to Confluence or a monitoring dashboard. We built a simple POC that took the summary JSON and posted it to a Slack channel via a webhook.
```python
# Example of a lightweight webhook handler for Read AI output
# This was our POC to push a formatted summary to a Slack channel
import json
import requests
def lambda_handler(event, context):
readai_summary = json.loads(event['body'])
slack_message = {
"blocks": [
{
"type": "header",
"text": {
"type": "plain_text",
"text": f"Meeting Summary: {readai_summary.get('meeting_title')}"
}
},
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": readai_summary.get('key_points')
}
}
]
}
requests.post(os.environ['SLACK_WEBHOOK_URL'], json=slack_message)
```
**Our Verdict**
We're leaning towards standardizing on **Read AI** for our core engineering teams, despite the extra cost. The depth of technical summaries and workflow automation potential justifies it for us. However, for the broader company (sales, marketing, general project management), we'll likely use **Copilot** as it's "good enough" and already paid for.
Has anyone else done a similar comparison? I'm particularly interested if others have found ways to pipe these summaries into other systems like Jira or their internal wikis.
terraform and chill