Digest Sloth: Drop Files In, Wake Up to a Digest 🦥

Muhammad Khizar — Tue, 20 Oct 2026 10:16:01 +0000

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

What I Built

Every team I know has the same graveyard: chat exports nobody re-reads, meeting notes nobody opens twice, long documents we all keep "meaning to get to". The information is in there — the decisions, the action items, the deadlines — but getting it back out costs more attention than anyone has.

Digest Sloth is my answer, and it takes the week's theme literally. You drop .txt or .md files into an inbox/ folder — a week of team chat, yesterday's meeting notes, that 30-page spec — and walk away. A small open-weight model running entirely on your own machine works through them the way a sloth would: one small chunk at a time, in no hurry, checkpointing its progress to disk after every single chunk. When you come back, there is one tidy digest.md waiting for you: a TL;DR for every file, the key points, and the action items pulled out as a checklist.

Who gets to be lazier? Anyone who has ever scrolled a 400-message chat thread at 9 AM trying to remember what was decided. The reading is done while your laptop is idle — overnight, over lunch, whenever. Interrupt it as often as life requires: close the lid, kill the process, run out of battery. It resumes exactly where it stopped and never redoes finished work. Slow, steady, and genuinely hard to break.

Demo

The whole thing runs locally, so the fastest demo is:

npm install
npm run demo     # seeds the inbox with a sample team chat + meeting notes
cat out/digest.md
npm run serve    # read the digest in your browser at http://localhost:4173

Code

khizzcr7 / digest-sloth

Drop files in, wake up to a digest. A slow-and-steady overnight digest agent powered by a local open-weight model (Qwen2.5-0.5B via Transformers.js). Built for DEV Hacktoberfest Week 3: Slow and Steady.

🦥 Digest Sloth

Drop files in. Wake up to a digest.

Digest Sloth is a tiny overnight digest agent for people who keep meaning to read things. Drop text files into a folder — team chat exports, meeting notes, long documents — and it works through them slowly: one small chunk at a time, powered by a local open-weight model, checkpointing after every chunk. In return you get a single tidy digest with a TL;DR, key points, and action items for each file.

Built for the Hacktoberfest Open-Source AI Challenge: Week 3 — Slow and Steady on DEV.

Why a sloth?

Because the design is the joke and the engineering:

Small chunks. A modest model on a modest laptop cannot swallow a 40-page document. It can absolutely summarize 130 words. So Digest Sloth splits everything into bite-sized pieces and map-reduces them into a summary — slow, steady, and…

View on GitHub

The project is a Node.js + TypeScript codebase (about 2,100 lines): a sentence-aware chunker, a local model wrapper, a checkpoint store, a CLI that doubles as a zero-dependency web viewer for the finished digest, plus the partner integrations below. Samples are included so npm run demo works the second you clone it.

How I Built It

The stack is deliberately boring, because the interesting decision is the model:

Model: Qwen2.5-0.5B-Instruct (Apache-2.0 open weights), run locally through Transformers.js in Node.js. No API key, no account, no cloud. The 4-bit quantized model downloads once (~750 MB) and every run after that works completely offline. (I first tried FLAN-T5, an encoder-decoder summarizer, and it kept echoing the input text back instead of summarizing — a small instruction-tuned model turned out to be the right tool.)
Chunking: files are split at sentence boundaries into ~130-word pieces. A small local model cannot swallow a whole document, but it can summarize 130 words beautifully — so the project is built around that limit instead of fighting it.
Map-reduce summarization: each chunk gets a one-or-two-sentence summary; those summaries are merged into a per-file TL;DR, and a final pass extracts action items and follow-ups.
Checkpointing (the "steady" half): after every chunk, the state is written to .state/progress.json atomically (temp file + rename, so a crash mid-write cannot corrupt it). Files are content-hashed, so editing one file in the inbox reprocesses only that file.
A tiny web viewer: npm run serve renders the digest in the browser with a hand-rolled Markdown converter and zero extra dependencies.

I picked a half-billion-parameter model on purpose: it is small enough to run on the kind of underpowered laptop most people actually have, and this challenge is about conserving energy – mine and the machine's. If your machine has more to give, one environment variable (MODEL_ID) points the same code at a larger open-weight model and the summaries get sharper.

The partner stack – every one of these was run for real on 20-23 October, inside the challenge window:

Gemma (Google): --model gemma swaps the brain to Google's Gemma 3 1B (open weights, ONNX) through the same pipeline – a full demo run produced a complete digest with zero cloud calls. Two open-weight models, one flag.
Mastra: the whole pipeline re-expressed as a typed Mastra workflow (npm run digest:mastra); ran both sample files through the local model and wrote a real digest.
Temporal: the same pipeline as a durable Temporal workflow – verified against a local Temporal dev server, worker bundled the workflow, client executed it, real digest written.
Sentry: a live traced run – one digest.run span over per-chunk model.chat spans, flushed cleanly to a real Sentry project.
Browserbase (Stagehand): drop a .url file in the inbox and it is fetched, chunked, and digested – verified end to end.
TabPFN (Prior Labs): scripts/tabpfn_priority.py scores every action item low/medium/high with TabPFN's tabular foundation model through the live Prior Labs API – real account, real token, real scores, verified end to end.
SerpApi: --enrich adds live web context to action items — verified end to end against the real SerpApi API on 23 October.

Honest limits: the repo also ships a render.yaml and code-complete integrations for ElevenLabs, MongoDB Atlas, Auth0, Tiger Data, Backboard, and Ultramarine, but Render needs a payment card on file before it will create even a free service, ElevenLabs' free API tier refuses library voices unless you pay, MongoDB Atlas wants the account password, and Auth0 and Backboard are parked at a phone verification step — so I am not claiming their prize categories. Tinker's API key is in hand and the SFT dataset builder ships in scripts/, but no fine-tune run has been submitted (Tinker serves hosted models, so a fine-tune cannot drop into the local ONNX pipeline anyway); not claimed. Arduino needs physical UNO Q hardware, which I do not have, so no claim there.

Why Does Open Innovation Matter?

This project only makes sense because the model is open:

Privacy is the feature. The entire point is feeding the tool your private group chats and internal meeting notes. With a closed API, the first thing your "lazy tool" does is upload your team's conversations to someone else's server. With open weights running locally, those files never leave the machine. For this use case, open is not a nice-to-have – it is the difference between a tool you can actually use and one you cannot.
It works offline. No connection, no problem. The digest runs on a train, in a village with patchy internet, during an outage.
It is free forever. Set it up once and it never asks for a subscription, a top-up, or a new pricing tier. Laziness should not have a monthly fee.
Anyone can adapt it. Swap in a bigger model on a beefier machine, a smaller one on a weaker laptop, or a model that speaks your language better – the code does not care, because nothing is locked behind one vendor's API.

The Lazy Payoff

I ran it on the bundled demo – a team chat export and a set of meeting notes, 726 words of source – on a modest 2-core machine:

~75 seconds end-to-end, 11 model calls, zero cloud calls. Out came a structured digest: a TL;DR per file, the key points, and an action-item checklist (it correctly pulled out things like "rework the settings page danger zone" and "prepare a one-page summary of the top ten support issues").
The second run took 0.3 seconds and made zero model calls. Every chunk resumed from its checkpoint. That is the honest test of the design: once the sloth has done a piece of work, it never does it again.
Scale that to a real week – several thousand words of chat and notes – and it is the difference between re-reading threads before standup and glancing at one page while the kettle boils. And because it checkpoints after every chunk, you can start it, close the laptop, and let tomorrow's run finish the job.

One honest limitation: a 0.5B model occasionally attributes a point to the wrong person. The substance stays faithful, and a bigger local model fixes most of the polish – but I would rather ship the version that runs on any laptop, privately, for free.

Prize Categories

Best Use of Gemma ($200 featured) – --model gemma preset, verified with a full local run
Best Use of Mastra ($100) – pipeline as a typed Mastra workflow, verified end to end
Best Use of Temporal ($100) – durable workflow verified against a local dev server
Best Use of Sentry ($100) – live traced run with per-chunk spans
Best Use of Browserbase ($100) – .url inbox files fetched and digested, verified end to end
Best Use of TabPFN ($200 featured) – action-item priority scoring through the live Prior Labs API, verified end to end
Best Use of SerpApi ($100) — --enrich web context for action items, verified end to end against the live API

DEV Community: Muhammad Khizar