AI Watchdog

Inspiration

Every one of us has sat in a meeting where someone proposed something that quietly contradicted a decision the team had already made — a budget cap from three weeks ago, a deadline that was supposedly locked, a scope boundary everyone had agreed to. Nobody catches it in the room. It surfaces days or weeks later as a costly surprise: a budget overrun in finance review, scope creep discovered at delivery, a policy violation found in an audit.

We looked at the AI meeting tools already on the market — Otter, Fireflies, Zoom's AI Companion, Gemini's meeting notes — and noticed they all do the same thing: summarize after the meeting ends. None of them act during the conversation. That gap was the whole idea. If an AI can transcribe a meeting in real time, it can just as easily compare what's being said, live, against what was already decided. So we built the tool that does that.

What it does

AI Meeting Watchdog listens to a live meeting and flags the exact moment someone says something that contradicts an existing policy, prior decision, or commitment.

You upload a reference document once at the start — a policy file, a set of meeting minutes, a project brief, a list of past decisions. The system parses it into a clean list of individual rules and shows them back to you immediately. From there, every sentence spoken in the meeting is silently checked against that list in real time. The instant someone says something that conflicts with a rule, an alert appears on screen naming the conflicting statement, the rule it breaks, and a one-sentence explanation of why.

It stays quiet the rest of the time — calibrated specifically to avoid false alarms, because a tool that interrupts on every unrelated sentence gets muted within minutes of real use.

How we built it

We kept the architecture deliberately minimal, since the entire product really comes down to one job done well: compare live transcript text against a reference document using an LLM.

Frontend: React + Vite. Speech-to-text runs entirely client-side using the browser's native Web Speech API — no audio file ever leaves the user's machine, only finalized transcript sentences are sent onward. We paired this with the Web Audio API to drive a live waveform visualizer tied to the mic input, plus a transcript panel, a policy panel, and an alert card for surfaced contradictions. On browsers without Web Speech API support, the UI automatically falls back to a manual paste-transcript box.

Backend: Python and FastAPI, exposing exactly two endpoints — /upload for the reference document and /analyze for each transcript sentence. Document text is extracted with PyPDF and python-docx depending on file type.

AI engine: Two LLM calls, both running on Groq's Llama 3.3 70B. We chose Groq specifically for its inference speed — the entire value proposition of this product lives or dies on latency, since a five-second delay between "sentence spoken" and "alert shown" would break the "interrupts in the moment" pitch. The first call turns a messy uploaded document into a clean list of short, self-contained, checkable rules. The second call takes one live transcript sentence plus that rule list and returns a structured verdict: either no contradiction, or a contradiction object with the exact flagged phrase, the rule it breaks, and a plain-English explanation.

Deployment: Backend on Railway, configured entirely through environment variables — API keys and CORS origin are never hardcoded. The frontend deploys as a static Vite build, also on Railway.

Challenges we ran into

Getting the contradiction-detection prompt right took real iteration. Early versions were either too trigger-happy, flagging tangentially related statements as conflicts, or too quiet, missing genuine contradictions phrased in a roundabout way. We had to explicitly tune the prompt to favor precision over recall — false alarms are more damaging to user trust than an occasional miss, so the system is designed to fail silently toward "no contradiction" whenever it's uncertain.

We also hit a deployment snag that's worth mentioning honestly: our repo is a monorepo with frontend/, backend/, and ai_engine/ all at the root, and getting Railway to correctly build the frontend as a separate service (rather than reusing the backend's Python start command) took a few rounds of fixing the Root Directory setting and a relative import path that pointed outside the frontend's actual build root once deployed in isolation.

What we learned

That the actual hard problem here isn't speech-to-text or LLM plumbing — both are largely solved, off-the-shelf pieces at this point. The hard problem is calibration: deciding what counts as a "real" contradiction versus noise, and designing the system to fail gracefully (silently, never with a crash or a false alarm) when the LLM call has any hiccup. We also learned a lot about scoping a hackathon project tightly — we deliberately said no to a database, user accounts, and multi-session persistence, and instead spent nearly all our time making the one core interaction (speak → detect → alert) fast and reliable.

What's next for AI Meeting Watchdog

Persistent multi-session storage (Redis or a lightweight database) so policies and history survive restarts.
Multi-speaker attribution, so the alert shows who said the contradicting statement.
Retrieval-based rule matching for very large policy documents, instead of sending the full rule list with every sentence.
Severity scoring to distinguish a minor inconsistency from a high-cost contradiction.
Native integration as a bot inside Zoom, Google Meet, and Microsoft Teams, so it works inside the tools teams already meet in.