This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

My head is full of small things all day: book the dentist, the gate code at my mom's, that blog idea, email the landlord about the heater. Writing them down properly means opening an app, picking a list, typing, choosing a date. So mostly I don't, and they're gone.

Mumble is the lazy version: a phone app with one big button. You say the thing, as messily as you like, and forget about it. At 3 AM, while you sleep, open models sort it all out. It has three screens, one for each part of the day.

1. Mumble it, then forget it. Tap the button and talk. "Okay, remind me to book the car service before the long weekend. Oh, and the cabin wifi password is pinecone forty two." Tap again, and it's saved. No list to pick, no date to type. The memo lands in Tonight's pile, marked waits for 3 AM, with a ▶ button so you can hear that it saved what you said.

2. Wake up to it sorted. At 3 AM a free GitHub Actions runner wakes up. Whisper turns each memo into text, Gemma pulls out the to-dos, events and notes, and plain code turns "before the long weekend" or "Thursday at 6" into real dates. In the morning, the Morning screen shows only what still needs you: what's happening, what to do, and new notes. One tap each: Done, Keep, Add to calendar or Dismiss, and every tap can be undone. On Sundays, a weekly review reads the whole week and tells you what you keep saying and what's slipping.

3. Find anything you said. Remember holds the notes you kept, plus a search over everything you ever mumbled. Search "cabin password" in December, and there it is.

It's slow on purpose. Nobody is awake at 3 AM to wait for it, so it runs on a free CPU instead of a paid GPU, and it costs nothing to run.

The lazy payoff

Mumble keeps score. For every memo it compares how long you spoke with how long the same thing would take by hand: typing the words at 40 words a minute, plus about 20 seconds to file each item into the right list with the right date.

Here's a real night from the demo. The demo voice spoke a week of everyday memos (a dentist call that keeps not happening, a gym membership to cancel, mom's birthday scarf, a meetup on Thursday) plus the one in the video: 9 memos, 70 seconds of talking, 220 words. The nap turned them into 16 items, and Morning opened with:

10 min saved. Last night: 9 memos, 1 min of mumbling instead of 11 min of typing and sorting.

Ten minutes a night doesn't sound like much. But it's ten minutes I'd never actually spend, which is why those things used to get lost.

Demo

Live: https://mumble-azure.vercel.app

Everything in the video is real. The memos were voiced with macOS say and played into the browser's microphone. Whisper and Gemma sorted them, mistakes included: "pinecone forty two" became "PimeCone 42". The weekly review is a real Ultramarine response, and it cost $0.0004. I recorded it on my local build, which runs the same code as the live site.

Sign in with Google or email. Each account only ever sees its own memos, gets 20 memos a day, and can be deleted with everything in it at any time.

One thing to know as a judge: this is a slow app. A memo you record now is sorted at the next 3 AM (Toronto time), so your own to-dos appear the next morning. Until then, the pile shows your memo and lets you play it back.

Designing for an app that answers tomorrow

Most AI apps answer in seconds. Mumble answers the next morning, and that changes the design. My first version showed a recording as "Memo at 11:15 PM · sleeping" and nothing else. When I tested it, I wasn't sure it had worked at all. A slow app has to do more to reassure you, so I rebuilt the flow around a few rules:

• Show the memo right away, even though nothing is sorted yet. A new memo appears at the top of the pile, highlighted, with its length and a ▶ button. The label says what will happen and when: waits for 3 AM.
• Close the loop the next day. Once sorted, the pile shows what you said in quotes and what it became ("Became 1 to-do · 1 note"), with a link to Morning.
• Morning is a to-do list, not an archive. It shows only what still needs you. Keep a note and it moves to Remember; mark a to-do Done and it's gone. Every tap shows "Done: Book car service · Undo", because a one-tap app needs a way back.
• Explain the idea before asking for anything. The sign-in screen describes the whole day in three steps (mumble, 3 AM, morning) before the Sign in button.
• Errors get a way out. If something fails to load, the screen says so and offers Try again instead of staying blank.

Code

MIT licensed. The phone app is plain HTML, CSS and JavaScript (an installable PWA, no build step). The API and the night shift are Python, with 63 tests.

How I Built It

Phone PWA ──▶ Vercel (free static site) ◀──▶ Auth0 (sign-in, free)
    │
    └─ /api ──▶ Vercel Function (Python, free) ──▶ Postgres + pgvector (Tiger Data, free)
                                                                 ▲
          3 AM cron ──▶ GitHub Actions (free CPU runner): Ollama + Gemma + Whisper

During the day: just save it. The app records at 16 kbps (speech sounds fine, and a 5-minute memo stays small), and the API stores the audio in Postgres until the nap. No model runs during the day, so the API is a tiny Python function on Vercel's free plan.

At 3 AM: the night shift. A scheduled GitHub Actions job starts Ollama on the runner's CPU and works through the pile:

1. faster-whisper (small) transcribes each memo.
2. Gemma (gemma4:e2b-it-qat, through Ollama, temperature 0, with a JSON schema) splits the transcript into items: a kind (to-do, event or note), a title, a detail, and the time phrase exactly as you said it.
3. Plain code does the dates, not Gemma. A small model is bad at date math, so it never does any. The phrase it copies must appear in the transcript, or it's thrown away. Then dateparser, plus a few rules, turns it into a timestamp: "tomorrow after work" means 6 PM, a bare "at 6" means 6 PM rather than the 6th of the month, and a day with no time gets 9 AM.
4. EmbeddingGemma embeds each item into pgvector. Run locally, Remember searches by meaning as well as by keyword. The free live API has no model at all, so there it searches by keyword.
5. The audio is deleted as soon as the memo is sorted.

Testing with my own voice found bugs that unit tests didn't. Whisper heard my gate code, "4471", and Gemma filed it as the time of the note, so the note became due in the year 4471. Now a "time" made only of digits goes back into the note's details, and any date more than two years out is thrown away. Both have tests.

Once a week: Ultramarine reads the whole week. Gemma sees one memo at a time. On Sundays, Ultramarine (ultramarine-1-flash by Paper Instruments) reads the week's item titles and details, never audio or transcripts. It says what only shows up across memos. In the demo week it noticed "call the dentist" said on three separate mornings, and never done. Every claim must cite the items it's based on, and claims that don't are dropped. There's at most one review per account per week, capped at 200 items, and Morning shows what each review cost.

Free, and it stays free. Every account has a daily allowance (20 memos, 6 MB of audio, 40 unsorted memos, 120 requests a minute), each night sorts at most 25 memos per account, and sign-ups stop at 50 accounts. That keeps a public demo inside the free tiers.

Why Does Open Innovation Matter?

Voice memos are about as private as data gets: half-formed thoughts, addresses, codes, health appointments. With open models, Mumble's audio goes to a model running on a runner that exists for one job and is then thrown away. The audio is deleted once it's sorted. No AI company ever hears it.

Open models also make "slow" a real design choice. A closed API charges per minute of audio and per token, so every memo would cost money forever. Whisper and Gemma on a free CPU runner cost $0. Being slow is the trade: it takes the runner a while, but nobody's awake to notice.

Nothing is locked in. Whisper, Gemma and EmbeddingGemma are swapped with an environment variable each, and Ollama runs the same models on my laptop as on the runner. Anyone can run the whole thing locally with MUMBLE_DEV=1, read the prompts, and check why Gemma made a to-do out of something you said.

The one closed model, Ultramarine, is optional and boxed in. Without its key, there's no weekly review and nothing leaves at all. With it, it reads only item text, cites its sources, and has a hard cap on cost.

Prize Categories

• Best Use of Gemma: Gemma does all the understanding. gemma4:e2b-it-qat turns rambling transcripts into structured items with a JSON schema, on a free CPU runner, and EmbeddingGemma embeds every item. The design plays to a small model's strengths: Gemma copies the time phrase, and code does the date math.
• Best Use of Tiger Data: a free Tiger Cloud Postgres service holds everything: the audio until it's sorted, items with tsvector full-text search, pgvector embeddings (fused with keyword search when a query vector is available), per-account quotas, and the weekly reviews.
• Best Use of Ultramarine (Paper Instruments): the weekly review reads a whole week of items at once and finds patterns a per-memo model can't. Every claim cites its items, uncited claims are dropped, and each review's cost is computed from the pricing endpoint and shown to you.
• Best Use of Auth0 for AI Agents: Auth0 (OAuth 2 with PKCE, rotating refresh tokens) decides whose memos the AI pipeline works on. The API checks signature, issuer, audience and app on every request. A new account needs a verified email. Every query, quota and nightly job is scoped to the signed-in account, so the night shift only ever sorts your memos into your Morning.

Thanks for reading. Now go mumble something and forget about it. 🦥