Meeting to Actions

• 

  Paste a meeting transcript, get conflict-free tasks and follow-up emails back.

• 

  Nemotron Super drafts one follow-up email per person, listing only their own tasks

• 

  Under the hood: three Nemotron models on Nebius Token Factory. Only Ultra reasons; a meeting costs about a cent

• 

  Nemotron Ultra catches the QA-vs-Friday clash and how the team resolved it, and keeps only the truly open questions

• 

  A product launch sync becomes a summary and six tasks, each with an owner, deadline, priority and reason

• 

  A standup with a dependency chain (schema → billing page → PDF) and a vacation handover to Ken

Inspiration

Every meeting ends the same way: tasks change hands mid-call, deadlines quietly clash, and a question asked in minute five gets answered in minute twenty. A plain summary just copies that mess into bullet points. Then someone has to untangle who actually owns what, and the follow-up email usually never gets sent.

I wanted a tool that does the untangling: paste in a transcript, get back a plan your team can act on.

What it does

Meeting-to-Actions turns a raw meeting transcript into:

• a task list with an owner, deadline, priority, dependencies and a one-line reason for each task
• conflicts found and how the meeting resolved them (or a flag if it didn't)
• decisions and the questions that are still open
• one follow-up email per person, with only their own tasks

Plans can be exported as a Markdown checklist, CSV or JSON.

How I built it

The core idea is tiered routing: each step goes to the smallest NVIDIA Nemotron model that can do it well, all served through Nebius Token Factory's OpenAI-compatible API.

Every call is logged with its model, tokens, latency and cost, and the UI shows it all in an "Under the hood" panel. The cost of a run is

$$ C = \sum_{s \,\in\, \text{steps}} \left( t^{\text{in}}s \, p^{\text{in}}{m(s)} + t^{\text{out}}s \, p^{\text{out}}{m(s)} \right) $$

where $t_s$ are the step's tokens and $p_{m(s)}$ the per-token price of the model that handled it. In practice a whole meeting costs about one cent.

Stack: Python and FastAPI, a single-page HTML UI, a 45-test suite (including tests of the live API path with a fake client), GitHub Actions CI, and Docker. The demo runs on Render's free tier; all inference runs on Token Factory.

Built to survive a live demo: long transcripts are split and extracted in parallel. If the Ultra step fails, the app falls back to Nano's raw extraction instead of erroring. Model replies are parsed tolerantly, with one repair attempt for bad JSON. A rate limit and daily cap protect credits on the public link, and the sample meetings replay from recorded real runs so they load instantly for judges.

How it was actually built: this project was vibe coded. I directed an AI coding assistant (Claude, by Anthropic), which wrote the code, tests, prompts, docs, demo video and thumbnail. I chose the idea and track, set up the Nebius, GitHub and Render accounts and keys, ran the live tests on real Nemotron models, deployed the demo, and made the calls along the way.

What I learned

• Reasoning isn't free, even on "cheap" models. Nemotron 3 models reason before answering by default. On the extraction step, Nano spent up to ~7,000 tokens and 12–24 seconds producing a ~500-token answer, and its first reply was cut off mid-thought and needed a retry. Turning reasoning off with chat_template_kwargs: {"enable_thinking": false} dropped extraction to ~2 seconds and cut its tokens by ~90%, with the same accuracy. Now only Ultra reasons, which is exactly where it pays off.
• Ultra's reasoning is genuinely good. On untuned prompts it passed all 11 of my targeted checks. It applied mid-meeting reassignments, turned a "QA needs three days but launch is Friday" clash into the team's staged-rollout decision, dropped questions answered later in the meeting, and built dependency chains like schema → billing page → PDF.
• Test the hard parts, not every line. A small smoke test that checks the tricky behaviours (reassignments, conflicts, dependencies) told me more than any amount of manual clicking.
• Measure before you brag. My first "savings vs. running everything on Ultra" number was inflated by Nano's wasted reasoning tokens. After the fix, the honest figure is smaller, and the real win is speed.

Challenges

• Case-sensitive model IDs. The Nemotron IDs on Token Factory use inconsistent casing (nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B vs nvidia/nemotron-3-super-120b-a12b), and lowercase versions from third-party listings fail. I added a check script that suggests the right ID.
• Hosting on Nebius AI Cloud. I set up the Nebius CLI (through WSL on Windows) and a GitHub Actions pipeline that publishes the Docker image. Every endpoint create still returned a bare PermissionDenied, even with an explicit project, subnet and a published image, and the error never said what was missing. To avoid spending money, I hosted the small web app on a free tier instead. Every model call still goes through Token Factory.
• Windows quirks. Python on Windows defaulted to an old text encoding, which crashed the report writer on the "≈" symbol and garbled "—" in the sample files. Everything now reads and writes UTF-8, and a test guards it.
• Keeping secrets out of Git. A typo in .gitignore briefly let the .env file into a commit while the repo was still private. I fixed the ignore file, removed the file from the commit history and force-pushed before making the repo public.

Built With

• ai-agents
• css
• docker
• fastapi
• github-actions
• github-container-registry
• html
• javascript
• llm
• nebius
• nebius-token-factory
• nemotron-nano
• nemotron-super
• nemotron-ultra
• nvidia-nemotron
• openai-sdk
• playwright
• pydantic
• pytest
• python
• render
• uvicorn