Noto

Turn meetings into action.

Noto turns messy meeting transcripts into evidence-backed, reviewable execution plans — with humans approving what becomes authoritative. Every decision, action item, owner, deadline, open question, and risk is tied back to the exact line in the transcript it came from. I built it as an AI Product Management portfolio project, and this README is my honest writeup of what it does, how it's built, what I evaluated, and what I got wrong along the way.

🔗 Live Demo: noto-meeting-execution.vercel.app · Repo: github.com/yash7536/noto-meeting-execution

The Problem

Meeting transcripts already contain everything you need: decisions, tasks, owners, deadlines, unresolved questions, and sometimes outright conflicting statements. The hard part was never summarizing the meeting — any LLM can do that in one prompt. The hard part is turning a messy conversation into something you can actually act on without quietly inventing information that was never said.

That's the failure mode I kept running into with plain LLM summarization: it sounds confident and clean, but it will happily assign an owner nobody volunteered for, pick a deadline out of a vague "sometime next week," or present a proposal as if the room had actually agreed on it. None of that is obvious until someone downstream trusts it and acts on the wrong thing.

What Noto Does

1. You paste a meeting transcript.
2. Gemini extracts candidate decisions, actions, open questions, and risks.
3. Every candidate has to be backed by an evidence quote from the transcript.
4. A deterministic (non-AI) validation layer checks that AI output before anyone sees it.
5. Ambiguity, conflicting statements, and superseded decisions get surfaced instead of silently resolved.
6. A human reviews every item — edits, approves, or rejects it.
7. Approved items get compiled into an execution plan.
8. From there, Noto generates a follow-up email draft and copy-ready Jira and Notion output.

One thing I want to be upfront about: Jira and Notion are copy-ready outputs, not live integrations. Noto formats the approved items into Jira ticket markup and Notion-ready markdown you can paste in — it doesn't call the Jira or Notion APIs. That was a deliberate scope call, not an oversight.

The Core Idea

AI proposes. The system validates. A human approves.

That principle breaks down into a few concrete rules the product actually enforces:

• No invented owners, deadlines, or decisions — if it isn't grounded in the transcript, it doesn't get asserted as fact.
• Evidence is first-class — every item carries the exact quote it came from, not a paraphrase.
• Uncertainty is surfaced, not resolved for you — unclear owners and vague deadlines get flagged, not guessed.
• Conflicts are preserved — when two people disagree, both positions are shown, not one silently picked.
• Superseded decisions retain history — a reversed decision keeps a link to what it replaced, not just the final answer.
• Exports only use approved items — nothing reaches the follow-up email, plan, or Jira/Notion output without a human approving it first.

The Gemini call in this app is a candidate generator, not an authority. It's never allowed to decide status, ownership, or approval on its own — those get computed by deterministic code that checks the model's output against the actual transcript. I did it this way because an LLM extracting structured facts from a conversation will occasionally be wrong in ways that look completely reasonable on the surface, and the cost of a wrong "decision" or a made-up owner showing up in a real execution plan is a lot higher than the cost of asking a human to confirm it. Human review isn't a fallback for when the AI fails — it's a required step for anything that leaves this system.

Before → After

Before

Meeting transcript
  → manually reread it to find decisions and tasks
  → figure out who owns what and by when
  → write a follow-up email by hand
  → create tickets one by one
  → risk missing something or misreading what was actually agreed

After

Transcript
  → AI extraction
  → evidence validation
  → ambiguity / conflict detection
  → human review
  → approved execution plan
  → email / Jira / Notion-ready output

How It Works

flowchart TD
    A[Messy Transcript] --> B[AI Extraction]
    B --> C[Evidence / Source Quotes]
    C --> D[Deterministic Validation]
    D --> E[Ambiguity + Conflict Detection]
    E --> F[Human Review]
    F --> G[Approved Execution Items]
    G --> H[Email / Jira / Notion]

AI Architecture

The app is a Next.js 16 / TypeScript project. When you submit a transcript, it's first parsed into individual turns — each one carries the speaker, a timestamp, and the text they said. Those turns get sent to the Gemini API with a schema that forces structured JSON output: a list of candidates, each with a type (decision / action / question / risk), a title, and — critically — the evidence it's grounded in.

That's where the AI's job ends and the deterministic layer takes over. For every candidate Gemini returns:

This is the beginning of the README. Read the rest at the original. Read the full README ↗