This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.
Draft review note: This project currently lives locally. Before publishing this entry, add a shareable source-code link and a hosted demo video below. Screenshots and a recording script are prepared with the project. This post was drafted with AI assistance and should be reviewed by the author.
What I Built
There is a particular kind of digital clutter that survives every productivity system: the receipt you might need, the meeting note named final-FINAL, the email you saved because it contained one important sentence.
Opening each file is easy. Deciding what matters, where it goes, and whether it asks anything of you is the tiring part.
Sloth Inbox does that first pass on your own machine. Drop in text files, let a local model read them, and return to a calm inbox with short summaries, suggested homes, and a brief of explicit follow-ups.
The small detail I care about most: a weekend idea stays an idea. A subscription notice that says “no action required” should not become another chore.
The workflow is deliberately small:
- Drop in notes, text receipts, or saved emails.
- Let Sloth read them through Ollama.
- Glance at a proposal beside the original; correct its category if needed.
- File a named copy, keeping the original untouched.
- Read one brief instead of opening the whole pile again.
There is also Autopilot: a watched local folder that checks for new files every 15 seconds while the application is running. It reads automatically; filing still waits for review.
Demo
A measured local run: six fictional documents, processed by gemma3:4b through Ollama in 15.1 seconds. That run used fresh inference results rather than the response cache; model download and installation time are excluded.
| What went in | What came back |
|---|---|
| Website meeting notes | A Work summary and one request to send Maya a homepage mockup |
| Coffee receipt | A concise purchase summary and no follow-up |
| Note about autumn leaves | A Learning summary and no invented research task |
| Landlord email | A Home summary and one request to confirm availability |
| Weekend brain dump | A Personal summary with no obligations attached |
| Subscription renewal notice | A Money summary with no instruction to cancel |
Code
Sloth Inbox 🦥
A little less inbox. A little more life.
A calm document inbox that uses local Ollama inference to read the pile you keep putting off. Drop in notes, text receipts, saved emails, and reference material. Get short summaries, proposed categories, and source-backed follow-ups. Review a proposal and Sloth writes an organized copy, leaving the original untouched.
Built for the Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady.
Run it
Requires Node.js 22.13+ (Node 24+ recommended) and Ollama. There are no npm dependencies and no build step.
ollama serve
If the Ollama desktop app is already running, its server is usually already available; skip ollama serve.
ollama pull gemma3:4b
npm start
Open http://127.0.0.1:3333. Click Try a sample inbox, then Let Sloth take care of it. The six examples are fictional and have no pre-generated AI answers. First inference may take longer…
It runs with Node.js 22.13+ and Ollama, with no npm dependencies and no frontend build step:
ollama pull gemma3:4b
npm start
Start the Ollama service first if its desktop application is not already running. The UI opens at http://127.0.0.1:3333 on your own machine.
How I Built It
The core is Gemma 3 4B running locally through Ollama. The model performs meaning-based classification, summary writing, and request extraction. A filename rule cannot distinguish a text receipt from a text learning note; that interpretation is where the model earns its place.
The surrounding application is intentionally small: a Node HTTP server, SQLite for durable state, vanilla JavaScript, responsive CSS, and an original SVG sloth. There are no remote fonts or analytics scripts.
Upload / watched folder
↓
Validate UTF-8 + deduplicate content
↓
SQLite → sequential queue → local Ollama
↓
Validate structured output + check request evidence
↓
Review → organized copy + daily brief
The Ollama request uses a JSON schema through the format field, stream: false, and temperature zero. The implementation follows Ollama’s structured output documentation, then validates the returned values again in application code.
The first live run taught me why valid JSON is only the beginning. The model quoted educational facts and turned them into suggestions to research things. It also promoted optional weekend activities into tasks. Every quote could exist in the source and still be the wrong obligation.
I revised the prompt, added explicit examples of when to return an empty action list, and introduced a conservative request filter. Accepted actions need a matching source quote and explicit request wording. Optional cancellation instructions, unsupported fragments, and duplicate quotes are excluded. That favors missing an ambiguous suggestion over manufacturing work for the user. It is a narrow English-language filter, and it is not a general solution to understanding commitments.
The final six-file fixture retained both explicit requests and produced no tasks from the four informational documents. The live check asserts those behaviors, in addition to verifying source quotes.
Small models still make mistakes. Gemma put the coffee receipt under Personal even though the prompt asked for receipts under Money. The review screen lets the user correct that before filing. That correction, filing the copy, finding it in the library, undoing it, and checking/unchecking a follow-up were all verified in the browser.
Seven automated tests cover the rest of the important boundaries: imports, content duplicates, SQLite restart recovery, malformed output, evidence filtering, loopback restrictions, origin checks, cached rereading, category correction, watched-folder ingestion, and file/undo behavior.
Why Does Open Innovation Matter?
The point of an inbox assistant is letting it see material you have been avoiding opening yourself. For a local pile of documents, sending the entire pile to another company is an uncomfortable prerequisite.
Ollama and downloadable weights let the reading happen on the same machine that holds the files. Once the runtime and model are installed, the inference path needs no internet connection. The application only permits a loopback Ollama endpoint, refuses redirects, and has no hosted-model fallback. It assumes a trusted local Ollama daemon; it does not independently audit that daemon’s networking.
There is also room to change the behavior. The model selector lists installed local models, the prompt is ordinary source code, the schema is inspectable, and the cache includes a model digest and prompt version. Swapping a model or tightening a policy does not require a provider to add a product feature.
Open weight access made this particular design practical: private batch processing without a hosted inference account, per-request charges, or a network connection during use. Hardware, memory, electricity, and review still have a cost. I have not benchmarked it against a closed API, and I am not claiming that a small local model has better accuracy.
The licenses matter too: the application is MIT, Ollama is open source, and Gemma is open-weight under its own terms, not an MIT-licensed model. These are different pieces of openness, each with a concrete role.
Two DEV posts shaped the implementation choices: Ollama Structured Outputs in Practice — Getting Type-Safe JSON from Local LLMs with Pydantic by @jangwook_kim_e31e7291ad98, on schema-constrained responses, and Local AI Is Not a Privacy Switch: Build a Workload Routing Contract by @isabelle_dubuis_d858453d7, on making the surrounding data path explicit. Their lesson for this build was practical: constrain the output and the destination, then verify both.
The Lazy Payoff
In the measured sample, six loose files became six readable summaries and two supported follow-ups in 15.1 seconds. Four documents asked nothing more of the reader.
That does not establish a human time-savings percentage. There has been no user study, and review time still matters. What it demonstrates is the intended interaction: one brief, fewer files to open, and a small set of requests with their evidence attached.
The current version accepts UTF-8 TXT, Markdown, EML, CSV, and JSON up to 18,000 characters per file. It does not parse PDFs, images, MIME attachments, or a live mailbox. The watched folder requires the app and computer to stay awake. The local database stores source text and should be protected like the originals.
The next useful improvement would be a broader evaluation set: more ways people ask for things, more languages, and more cases where the best response is to leave the person alone.
For now, the sloth can handle the first pass. The afternoon stays yours.
Prize Categories
Best Use of Gemma: Gemma 3 4B performs the document interpretation locally through Ollama. No other partner integrations are claimed.
Top comments (0)