MOGI - Meeting Overlay for Group Intelligence

Real-time meeting overlay that classifies live discussion into structured minute cards and runs 5-persona AI deliberation with Amazon Nova — validating every decision from five distinct perspectives.

Comment

Inspiration

Meetings often end with everyone nodding — but did the team truly agree, or did they just avoid conflict? False consensus is one of the biggest silent risks in decision-making. Important objections go unspoken, edge cases get overlooked, and the team moves forward on a decision that only seemed solid.

We wanted to build a system that acts as a real-time "second opinion layer" for meetings — one that listens, organizes, and then challenges decisions from multiple perspectives before they become final.

What it does

MOGI (Meeting Overlay for Group Intelligence) captures live meeting audio and:

  1. Classifies discussion into structured minute cards in real time — Decisions, issues, and tasks with owners and deadlines are extracted as people speak
  2. Runs 5-persona AI deliberation on each decision — Each persona has a distinct role (empathy advocate, technical fact-checker, risk analyst, chair, creative disruptor) and independently votes GO / HOLD / NO
  3. Surfaces false consensus — If the team agreed too quickly, the personas expose gaps: missing rollback criteria, unclear ownership, untested assumptions
  4. Shows the full deliberation chat — Brainstorm, debate, vote results, points of agreement/disagreement, chair summary, and a one-liner takeaway

The core narrative: False consensus → Persona intervention → Deeper discussion → Stronger decision.

How we built it

The entire system runs on AWS with Amazon Nova at its core:

Amazon Nova Model Purpose
Amazon Nova Pro (Bedrock) Card generation — classifying live utterances into decision / issue / task cards
Amazon Nova Pro (Bedrock) 3-stage deliberation engine — brainstorm → debate → weighted vote
Amazon Nova Lite (Bedrock) Thread resolution — closed-set topic selection for grouping related cards
Amazon Titan Embeddings (Bedrock) Semantic similarity for issue clustering

Supporting AWS services:

  • Amazon Chime SDK — Live meeting audio capture with built-in speaker separation
  • Amazon Transcribe — Real-time speech-to-text
  • AWS Lambda — Serverless compute for classify, deliberation worker, HTTP handler
  • Amazon DynamoDB — Single-table design for meetings, minutes, and deliberation results
  • Amazon SQS — Async deliberation queue
  • Amazon API Gateway — HTTP API + WebSocket API for real-time card updates
  • Amazon S3 + CloudFront — Frontend hosting
  • AWS Amplify Hosting — MOGI-D deliberation review page (Next.js SSR)
  • AWS CDK — Infrastructure as Code (entire stack deployable in one command)

We also built a Persona Studio with 10 AI personas in 2 swappable teams — a modern anime-style team and a Sengoku (Warring States) warlord team — each with unique personality, risk tolerance, and decision rules.

Challenges we ran into

  • LLM non-determinism: The same 9-minute meeting audio produced 7 display cards in one run and 13 in the next. Raw topic seeds from Nova varied too much between runs. We solved this by moving away from free-text topic keys to structured signal extraction (action/scope/duration/issue-kind) combined with embedding-based thread clustering and a category stabilizer — achieving stable 6-7 card output across repeated runs.

  • Bedrock timeout under batch load: Demo playback mode sends many classify requests in rapid succession. Nova Pro responses occasionally exceeded our initial 2.5-second timeout, causing the entire playback to halt. We tuned timeout thresholds to 8 seconds and added graceful error skipping so one slow response doesn't kill the whole session.

  • Speaker attribution without multiple microphones: In single-device testing, all speakers appear as "Dev User." We built vocative pattern extraction — detecting "Jordan, please define..." patterns in transcript text — to recover correct task owners even when speaker diarization isn't available.

  • Thread stability across runs: Proposal-to-decision promotion, issue deduplication, and representative card selection required a 3-layer resolution chain (rule-based pre-filter → embedding similarity → signal matching) to ensure the same topics consistently group together regardless of LLM wording variations.

  • Deliberation target categories: Initially all card types triggered deliberation, flooding the system with unnecessary GO/HOLD/NO votes on issues and tasks. We refined the deliberation scope to proposals and decisions only — the cards that actually need a multi-perspective check.

Accomplishments that we're proud of

  • Stable 6-7 card output from a 9-minute meeting with 4 speakers — consistently hitting our smoke gate targets (decision=1, issue≤3, task=3) across multiple runs
  • Genuine multi-perspective deliberation — each persona argues from their distinct viewpoint with real personality, not just rubber-stamping the same conclusion in different words
  • Zero external dependencies — the entire system runs on AWS. No Google OAuth, no Vercel, no external APIs. One CDK deploy and it works.
  • Real-time card generation — cards appear as people speak, not after the meeting ends. You can watch the meeting structure emerge live.
  • 10 swappable AI personas with full character portraits, personalities, and decision rules — including a Sengoku warlord team where Oda Nobunaga pushes for speed while Tokugawa Ieyasu demands caution
  • Full deliberation review page with animated chat history showing brainstorm and debate phases, matching the original MOGI-D experience

What we learned

  • Amazon Nova Pro is remarkably capable at structured extraction tasks when given well-designed prompts with closed-set constraints rather than free-text generation
  • Multi-agent deliberation works best when each agent has a clearly distinct role and risk tolerance, not just different names — the personality differences drive genuinely different voting patterns
  • The biggest quality lever wasn't the LLM model itself — it was the post-processing pipeline (thread resolution, display eligibility, representative selection, category stabilization)
  • Testing LLM-powered systems requires distribution-based evaluation (median, IQR, stability index over N runs), not point expectations ("this input should produce exactly this output")
  • Embedding similarity + rule-based signals together are more stable than either alone for topic grouping — embeddings catch paraphrases, rules catch domain-specific patterns

What's next for MOGI - Meeting Overlay for Group Intelligence

  • LLM Thread Resolver (Layer 3): Using Nova Lite as a closed-set selector for ambiguous thread assignments — asking "which existing thread does this belong to?" instead of generating new topic keys
  • Stability testing at scale: Automated n=20 replay testing with statistical confidence gates (IQR ≤ 2, Stability Index ≥ 0.8)
  • Universal Thread Signals: Moving beyond meeting-specific dictionaries to agenda-driven dynamic signal extraction — so MOGI works for any meeting topic, not just enterprise onboarding
  • Thread State Machine: Modeling proposal → decision as explicit state transitions within a thread, rather than flag-based operations on individual cards
  • Pipeline Snapshot Replay: Recording LLM outputs at each stage so thread resolution logic can be tested without re-invoking Bedrock — reducing test cost by 99%
  • Multi-language deliberation: Japanese-language personas with culturally adapted decision styles and meeting conventions

Built With

Share this project:

Updates

Submission history