Email became my second job, so I built Snoozebox: a sleepy inbox where Gemma reads my mail and Snorlax eats my tasks

Shreyas Prajapati — Sun, 25 Oct 2026 13:13:49 +0000

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

One morning I opened my inbox and found an email from Internshala saying my L'Oréal application was not complete. It was already 17 hours overdue. It was sitting between a Codeforces reminder and three LinkedIn job alerts.

I'm not bad at email. Email is just built so that everything looks equally important. A thread with five replies gives you five notifications, and the one message with a real deadline looks exactly like the newsletter above it.

So I built Snoozebox. Your inbox, asleep on the job. Mostly.

TL;DR. Snoozebox is a local-first email manager. Gemma 2 2B runs on your own laptop through Ollama, reads your Gmail, sorts it, pulls out deadlines, merges threads into single tasks and gives you a 30-second morning report. Every label comes with a real quote from the email. Nothing leaves your computer, and every email costs €0.

What I Built

A morning report with Snorlax in it. It says things like "Only one thing is worth waking up for today." Each urgent item shows what to do, when it's due, and the exact line from the email that proves it.
One task per thread. If someone emails Tuesday, follows up Wednesday and moves the deadline on Thursday, you get one task. The old date is crossed out and the new one is highlighted.
Quotes or nothing. Every priority label is backed by a verbatim quote. If the model can't quote it, the email is marked "Not analyzed" and you check it yourself.
Deadlines in plain words. "Friday noon" and "before 6 PM today" are turned into real timestamps by code, not guessed by the model.
Quiet hours. From 22:00 to 08:00 nothing gets through except your VIP senders.
Done means munch. Hit Done and Snorlax eats the task. You get five seconds to undo it.

I picked Snorlax because the challenge theme is "reward laziness", and nobody is lazier or more committed to it.

Why not just ask a cloud model?

An inbox is one of the most private things on a computer. Mine has contracts, password resets, flight details and job applications. I didn't want to send that to someone else's API, and I didn't want to pay per token for 100 emails a day.

So everything runs locally. Gemma 2 2B uses about 1.6 GB of VRAM and runs at roughly 62 tokens per second on my RTX 3050 laptop GPU. It's a small model, which brings me to the main design rule.

How I Built It

Gemma reads, code checks. The model suggests a category, a priority, an action and a supporting quote. Then plain code takes over: it checks that the quote really appears in the email, converts date phrases into exact timestamps, and decides which messages belong to the same task. A 2B model is good at reading and bad at being exact, so I never ask it to be exact.

The stack is a Go backend, pure-Go SQLite (no CGO, so it builds on Windows without drama), a React 19 and TypeScript frontend served by the same Go binary, and the Gmail API with the OAuth token stored only on disk.

Does it work?

I wrote 30 test emails with known answers and ran the whole pipeline on them.

Metric	Result
Urgent recall	3 of 3
Urgent precision	3 of 3
Deadlines exactly right	16 of 17 (94.1%)
Speed	about 62.5 tokens/sec

This is a small test. Three urgent emails proves nothing about the real world. It tells me the pipeline isn't broken, not that it's finished. [ONE LINE: describe the one deadline it got wrong and why.]

Bugs I'm not proud of

When I connected my real Gmail, things got embarrassing fast:

The same task appeared twice on the Morning screen, so the "items that need your brain" counter was wrong.
The screen said "1 threads" and "1 urgent things".
A backend JSON error showed up with a green check mark next to it.
Emails all showed the same time instead of when they actually arrived.

The test data was too clean to catch any of this. Real inboxes are messy, and I'd recommend connecting a real one earlier than I did.

My first design looked like a robot made it

The first redesign was tidy and looked like every AI dashboard: identical white cards, identical stat tiles, a tiny mascot in the corner. So I rebuilt it around one character, gave the copy a dry and sleepy voice, and made Snorlax react to how many urgent items there are. Zero urgent and he sleeps. A few and he opens an eye.

Before

After

When you hit Done, the card shrinks toward Snorlax, he munches, and a toast says "Munch." with an Undo button. This is the part I'm proudest of, and it took the least code.

Why Open Innovation Matters

This only makes sense if the model is free to run and stays on your machine. With open weights nobody pays per email, and your inbox never trains anyone's next model.

The honest tradeoff is that a small local model is less clever than a frontier one. That's why code handles everything that must be exact, and why anything uncertain is labeled "Not analyzed" instead of being guessed.

What I Learned

A small model works well when it only has to read and quote. The moment I asked it to also be right about dates, it stopped being reliable, so dates became code.
Making the app say "I don't know" is a feature. The "Not analyzed" badge makes the other labels easier to trust.
Lazy software is harder to build than busy software. The best moment in the app is when you do nothing.

Prize Categories

Best Use of Gemma: Gemma 2 2B through Ollama does all the reading, entirely on a laptop GPU.

Code: Github
Demo video: Youtube
Snorlax is © Nintendo / Creatures / GAME FREAK. This is a fan project, not affiliated.

I drafted this post with AI help and edited it myself. The numbers come from the test suite in the repo.

DEV Community: Shreyas Prajapati