DEV Community: Akshra Jain

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

Akshra Jain — Sun, 25 Oct 2026 07:45:38 +0000

What I Built

Every morning, most of us wake up to 500+ unread WhatsApp messages across family groups, college groups, project teams, and neighborhood associations. Scrolling through them is exhausting. What if you could just get a calm, two-paragraph summary of:

What actually happened
What needs you specifically (bills, tasks, direct questions)
Upcoming deadlines and events

I built SlothDigest — a local-first CLI agent that does exactly that. Drop your WhatsApp .txt exports into an inbox/ folder, run one command, and get a clean digest in Markdown, HTML, or even an .ics calendar file.

It runs 100% locally using open-weight models via Ollama. No data ever leaves your machine. Privacy-first by design.

And because mornings should be lazy, it has Sloth Mode — if your laptop is on battery or the CPU is busy, it defers processing until you're plugged in and relaxed. 🦥

Demo

The tool runs from your terminal, but there's also a Flask web UI for those who prefer a browser:


bash
# One-time setup
slothdigest init --name "Raha" --model qwen2.5:7b-instruct

# Run the digest
slothdigest run

# Or use the web UI
python run_webui.py
# Opens at http://localhost:5000
# SlothDigest — 2026-10-24

## family_group.txt
**Mom's planning Diwali dinner on Nov 1, and Dad fixed the WiFi router**

- Papa called Airtel and the WiFi will be back by evening
- Mom confirmed Diwali dinner — everyone needs to bring one dish
- Rohan scored 92% on his math test 🎉

## needs_you
### family_group.txt
- **Mom** (14:32): Raha, can you pick up sweets from Bikanervala on the way home?
- **Dad** (15:10): Beta, send me the Airtel bill number, I need to follow up

## deadlines
- **Diwali dinner** (event) — 2026-11-01
- **Airtel bill payment** (payment) — 2026-10-25
- **Rohan's PTM** (event) — 2026-10-28 at 10:00
git clone https://github.com/akshrakothari/SlothDigest.git
cd SlothDigest
pip install -e .
slothdigest init --name "Your Name"
# Drop WhatsApp exports into inbox/
slothdigest run
inbox/              ← Drop WhatsApp .txt exports here
src/slothdigest/
├── cli.py          ← Typer CLI (init/run/schedule/wipe)
├── config.py       ← JSON config in ~/.config/slothdigest/
├── parser.py       ← Android & iOS chat export parser with Hinglish date support
├── noise_filter.py ← Drops system messages, spam, forwards
├── chunker.py      ← Smart message chunking that preserves conversation threads
├── summarizer.py   ← Map-reduce summarization pipeline
├── ollama_client.py← Ollama local LLM client
├── deadlines.py    ← Deadline extraction with relative date resolution ("kal", "parso")
├── needs_you.py    ← "Needs you" detection (mentions, questions, tasks)
├── renderer.py     ← Outputs MD + HTML + ICS
├── sloth_mode.py   ← Defers when on battery or high CPU
├── privacy.py      ← Network guard, data wipe
├── scheduler.py    ← Windows schtasks / cron installer
├── state.py        ← Incremental processing via state files
├── pipeline.py     ← Orchestrates everything
└── webui.py        ← Flask web UI (optional)
tests/              ← Pytest test suite
How I Built It
The open-source AI stack
Ollama — The backbone. Every LLM call goes to a local Ollama instance. I tested with:

Qwen 2.5 7B (default — great balance of speed + quality)
Llama 3.1 8B
Gemma 2 9B
Mistral 7B
The model handles four specific tasks, each with a carefully crafted prompt:

Chunk summarization — "Summarize these messages in 3-5 bullet points"
Reduce step — "Combine chunk summaries into a 2-line overall summary + 3 highlights"
Deadline extraction — "Extract deadlines, tasks, events, and payment obligations"
Needs-you detection — "Which messages need this person's attention?"
Temperature 0.1 keeps the model grounded and factual. Every prompt asks for structured JSON output, with robust fallback parsing if the model hallucinates the format.

How the pipeline works
┌──────────┐   ┌───────────┐   ┌────────────┐   ┌──────────┐
│ WhatsApp  │   │   Parser  │   │ Noise      │   │  Chunker │
│ .txt file │──▶│ (Android/ │──▶│ Filter     │──▶│ (smart   │
│           │   │  iOS)     │   │            │   │  windows)│
└──────────┘   └───────────┘   └────────────┘   └──────────┘
                                                      │
                                                      ▼
┌──────────┐   ┌───────────┐   ┌───────────────────────┐
│ Renderer │◀──│  Reducer  │◀──│  Chunk Summarizer     │
│ MD+HTML  │   │  (final   │   │  (Ollama map step)    │
│ + ICS    │   │  digest)  │   └───────────────────────┘
└──────────┘   └───────────┘

The agent that built itself
Here's the wild part: most of this code was written by an AI coding agent. I described the architecture, and the agent wrote the 16+ source files, 10 test files, and the deploy infrastructure — all in a single continuous session.

This is the future of open-source contribution: describe what you want, and let AI handle the implementation while you focus on design, privacy, and architecture decisions.

Why Does Open Innovation Matter?
This project would be impossible without open innovation.

If I had built SlothDigest with a closed API like OpenAI or Claude:

Privacy nightmare — Every WhatsApp message would be sent to a US-based server. Family conversations, payment screenshots, medical discussions — all processed by a third party.
No customization — I couldn't tune the prompts for WhatsApp-specific patterns (Hinglish dates, emoji-heavy texts, voice-message references).
No offline use — No internet at your parents' village house? Too bad. No server connectivity? No digest.
Vendor lock-in — If the API changes pricing or policies, the project breaks.
No experimentation — I tested 4 different models and picked the best one. With closed APIs, you use what theygive you.
Open-weight models (Qwen, Llama, Mistral, Gemma) running locally via Ollama make this project possible. The model runs on a $0 inference budget. Your data stays on your laptop. You can audit every single prompt and response.

Open innovation means privacy-first, cost-free, customizable AI that anyone can run, modify, and trust.

My Agent Session
This project was built in a single continuous AI-agent session using Backboard's dev platform. The agent read the project requirements, created the architecture, wrote every line of source code, generated the test suite, built the deploy infrastructure, and assembled this blog post.

The session spanned:

16 source modules (parser, chunker, summarizer, renderer, etc.)
10 test files covering every module
3 output formats (Markdown, HTML, iCalendar)
Web UI with Flask (dashboard, upload, digest viewer, config)
Deploy automation (35+ file assembly from scattered source directories)
The Lazy Payoff
Here's what SlothDigest actually saves you every morning:

Without SlothDigest With SlothDigest
Scroll through 500+ messages    Read a 2-paragraph digest
15-20 minutes of doom-scrolling 30 seconds of browsing
Miss deadlines in noisy chats   Deadlines extracted to your calendar
Forget to reply to someone who asked you    "Needs you" section catches it
Read ads, forwards, "Good morning!" images  Noise filter drops them automatically
The name "SlothDigest" is a double joke — it works like a slow, thoughtful sloth (deferring work), and it saves you time so you can be the sloth.

Prize Categories
General — Complete, functional open-source AI project
Weekly Challenge: Week 3 — Slow and Steady — Sloth mode literally defers processing. The should_defer() function checks battery status and CPU load before running the pipeline. It's "slow and steady" by design — the digest waits until you're plugged in and relaxed.
-Backboard Studio
-Cursor
-Github Copilot
SlothDigest v0.1.0 — Built with 🦥 in October 2026 for Hacktoberfest.

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

Akshra Jain — Sat, 24 Oct 2026 09:31:15 +0000

What I Built

What actually happened
What needs you specifically (bills, tasks, direct questions)
Upcoming deadlines and events

It runs 100% locally using open-weight models via Ollama. No data ever leaves your machine. Privacy-first by design.

And because mornings should be lazy, it has Sloth Mode — if your laptop is on battery or the CPU is busy, it defers processing until you're plugged in and relaxed. 🦥

Demo

The tool runs from your terminal, but there's also a Flask web UI for those who prefer a browser:


bash
# One-time setup
slothdigest init --name "Raha" --model qwen2.5:7b-instruct

# Run the digest
slothdigest run

# Or use the web UI
python run_webui.py
# Opens at http://localhost:5000
# SlothDigest — 2026-10-24

## family_group.txt
**Mom's planning Diwali dinner on Nov 1, and Dad fixed the WiFi router**

- Papa called Airtel and the WiFi will be back by evening
- Mom confirmed Diwali dinner — everyone needs to bring one dish
- Rohan scored 92% on his math test 🎉

## needs_you
### family_group.txt
- **Mom** (14:32): Raha, can you pick up sweets from Bikanervala on the way home?
- **Dad** (15:10): Beta, send me the Airtel bill number, I need to follow up

## deadlines
- **Diwali dinner** (event) — 2026-11-01
- **Airtel bill payment** (payment) — 2026-10-25
- **Rohan's PTM** (event) — 2026-10-28 at 10:00
git clone https://github.com/akshrakothari/SlothDigest.git
cd SlothDigest
pip install -e .
slothdigest init --name "Your Name"
# Drop WhatsApp exports into inbox/
slothdigest run
inbox/              ← Drop WhatsApp .txt exports here
src/slothdigest/
├── cli.py          ← Typer CLI (init/run/schedule/wipe)
├── config.py       ← JSON config in ~/.config/slothdigest/
├── parser.py       ← Android & iOS chat export parser with Hinglish date support
├── noise_filter.py ← Drops system messages, spam, forwards
├── chunker.py      ← Smart message chunking that preserves conversation threads
├── summarizer.py   ← Map-reduce summarization pipeline
├── ollama_client.py← Ollama local LLM client
├── deadlines.py    ← Deadline extraction with relative date resolution ("kal", "parso")
├── needs_you.py    ← "Needs you" detection (mentions, questions, tasks)
├── renderer.py     ← Outputs MD + HTML + ICS
├── sloth_mode.py   ← Defers when on battery or high CPU
├── privacy.py      ← Network guard, data wipe
├── scheduler.py    ← Windows schtasks / cron installer
├── state.py        ← Incremental processing via state files
├── pipeline.py     ← Orchestrates everything
└── webui.py        ← Flask web UI (optional)
tests/              ← Pytest test suite
How I Built It
The open-source AI stack
Ollama — The backbone. Every LLM call goes to a local Ollama instance. I tested with:

Qwen 2.5 7B (default — great balance of speed + quality)
Llama 3.1 8B
Gemma 2 9B
Mistral 7B
The model handles four specific tasks, each with a carefully crafted prompt:

Chunk summarization — "Summarize these messages in 3-5 bullet points"
Reduce step — "Combine chunk summaries into a 2-line overall summary + 3 highlights"
Deadline extraction — "Extract deadlines, tasks, events, and payment obligations"
Needs-you detection — "Which messages need this person's attention?"
Temperature 0.1 keeps the model grounded and factual. Every prompt asks for structured JSON output, with robust fallback parsing if the model hallucinates the format.

How the pipeline works
┌──────────┐   ┌───────────┐   ┌────────────┐   ┌──────────┐
│ WhatsApp  │   │   Parser  │   │ Noise      │   │  Chunker │
│ .txt file │──▶│ (Android/ │──▶│ Filter     │──▶│ (smart   │
│           │   │  iOS)     │   │            │   │  windows)│
└──────────┘   └───────────┘   └────────────┘   └──────────┘
                                                      │
                                                      ▼
┌──────────┐   ┌───────────┐   ┌───────────────────────┐
│ Renderer │◀──│  Reducer  │◀──│  Chunk Summarizer     │
│ MD+HTML  │   │  (final   │   │  (Ollama map step)    │
│ + ICS    │   │  digest)  │   └───────────────────────┘
└──────────┘   └───────────┘

The agent that built itself
Here's the wild part: most of this code was written by an AI coding agent. I described the architecture, and the agent wrote the 16+ source files, 10 test files, and the deploy infrastructure — all in a single continuous session.

This is the future of open-source contribution: describe what you want, and let AI handle the implementation while you focus on design, privacy, and architecture decisions.

Why Does Open Innovation Matter?
This project would be impossible without open innovation.

If I had built SlothDigest with a closed API like OpenAI or Claude:

Privacy nightmare — Every WhatsApp message would be sent to a US-based server. Family conversations, payment screenshots, medical discussions — all processed by a third party.
No customization — I couldn't tune the prompts for WhatsApp-specific patterns (Hinglish dates, emoji-heavy texts, voice-message references).
No offline use — No internet at your parents' village house? Too bad. No server connectivity? No digest.
Vendor lock-in — If the API changes pricing or policies, the project breaks.
No experimentation — I tested 4 different models and picked the best one. With closed APIs, you use what theygive you.
Open-weight models (Qwen, Llama, Mistral, Gemma) running locally via Ollama make this project possible. The model runs on a $0 inference budget. Your data stays on your laptop. You can audit every single prompt and response.

Open innovation means privacy-first, cost-free, customizable AI that anyone can run, modify, and trust.

My Agent Session
This project was built in a single continuous AI-agent session using Backboard's dev platform. The agent read the project requirements, created the architecture, wrote every line of source code, generated the test suite, built the deploy infrastructure, and assembled this blog post.

The session spanned:

16 source modules (parser, chunker, summarizer, renderer, etc.)
10 test files covering every module
3 output formats (Markdown, HTML, iCalendar)
Web UI with Flask (dashboard, upload, digest viewer, config)
Deploy automation (35+ file assembly from scattered source directories)
The Lazy Payoff
Here's what SlothDigest actually saves you every morning:

Without SlothDigest With SlothDigest
Scroll through 500+ messages    Read a 2-paragraph digest
15-20 minutes of doom-scrolling 30 seconds of browsing
Miss deadlines in noisy chats   Deadlines extracted to your calendar
Forget to reply to someone who asked you    "Needs you" section catches it
Read ads, forwards, "Good morning!" images  Noise filter drops them automatically
The name "SlothDigest" is a double joke — it works like a slow, thoughtful sloth (deferring work), and it saves you time so you can be the sloth.

Prize Categories
General — Complete, functional open-source AI project
Weekly Challenge: Week 3 — Slow and Steady — Sloth mode literally defers processing. The should_defer() function checks battery status and CPU load before running the pipeline. It's "slow and steady" by design — the digest waits until you're plugged in and relaxed.
-Backboard Studio
-Cursor
-Github Copilot
SlothDigest v0.1.0 — Built with 🦥 in October 2026 for Hacktoberfest.

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

Akshra Jain — Sat, 24 Oct 2026 07:29:54 +0000

What I Built

What actually happened
What needs you specifically (bills, tasks, direct questions)
Upcoming deadlines and events

It runs 100% locally using open-weight models via Ollama. No data ever leaves your machine. Privacy-first by design.

And because mornings should be lazy, it has Sloth Mode — if your laptop is on battery or the CPU is busy, it defers processing until you're plugged in and relaxed. 🦥

Demo

The tool runs from your terminal, but there's also a Flask web UI for those who prefer a browser:

# Run the digest
slothdigest run

# Or use the web UI
python run_webui.py
# Opens at http://localhost:5000

Generated digest (Markdown):

# SlothDigest — 2026-10-24

## family_group.txt
**Mom's planning Diwali dinner on Nov 1, and Dad fixed the WiFi router**

- Papa called Airtel and the WiFi will be back by evening
- Mom confirmed Diwali dinner — everyone needs to bring one dish
- Rohan scored 92% on his math test 🎉

## needs_you
### family_group.txt
- **Mom** (14:32): Raha, can you pick up sweets from Bikaner vala on the way home?
- **Dad** (15:10): Beta, send me the Airtel bill number, I need to follow up

## deadlines
- **Diwali dinner** (event) — 2026-11-01
- **Airtel bill payment** (payment) — 2026-10-25
- **Rohan's PTM** (event) — 2026-10-28 at 10:00

The same content is rendered as a beautiful 📱 phone-friendly HTML page and an .ics calendar file you can import into Google Calendar or Apple Calendar.

Code

The entire project is open source on GitHub:

🔗 github.com/akshrakothari/SlothDigest

Quick start

git clone https://github.com/akshrakothari/SlothDigest.git
cd SlothDigest
pip install -e .
slothdigest init --name "Your Name"
# Drop WhatsApp exports into inbox/
slothdigest run

Architecture at a glance

inbox/              ← Drop WhatsApp .txt exports here
src/slothdigest/
├── cli.py          ← Typer CLI (init/run/schedule/wipe)
├── config.py       ← JSON config in ~/.config/slothdigest/
├── parser.py       ← Android & iOS chat export parser with Hinglish date support
├── noise_filter.py ← Drops system messages, spam, forwards
├── chunker.py      ← Smart message chunking that preserves conversation threads
├── summarizer.py   ← Map-reduce summarization pipeline
├── ollama_client.py← Ollama local LLM client
├── deadlines.py    ← Deadline extraction with relative date resolution ("kal", "parso")
├── needs_you.py    ← "Needs you" detection (mentions, questions, tasks)
├── renderer.py     ← Outputs MD + HTML + ICS
├── sloth_mode.py   ← Defers when on battery or high CPU
├── privacy.py      ← Network guard, data wipe
├── scheduler.py    ← Windows schtasks / cron installer
├── state.py        ← Incremental processing via state files
├── pipeline.py     ← Orchestrates everything
└── webui.py        ← Flask web UI (optional)
tests/              ← Pytest test suite

Key design decisions

Decision	Why
100% local	Your WhatsApp data never touches the cloud. Only allowed Ollama URLs are reachable.
Map-reduce summarization	Handles 1000+ messages by chunking, summarizing each chunk, then reducing into a final digest.
Incremental processing	Tracks last-processed timestamps — only new messages are summarized.
Quiet-night detection	If a chat has <10 meaningful messages, it just says "Quiet night".
Sloth mode	Defers processing when on battery or CPU > 80%.
Hinglish support	Understands "kal" (yesterday/tomorrow), "parso" (day after), "agle somwar" (next Monday).

How I Built It

The open-source AI stack

Ollama — The backbone. Every LLM call goes to a local Ollama instance. I tested with:

Qwen 2.5 7B (default — great balance of speed + quality)
Llama 3.1 8B
Gemma 2 9B
Mistral 7B

The model handles four specific tasks, each with a carefully crafted prompt:

Chunk summarization — "Summarize these messages in 3-5 bullet points"
Reduce step — "Combine chunk summaries into a 2-line overall summary + 3 highlights"
Deadline extraction — "Extract deadlines, tasks, events, and payment obligations"
Needs-you detection — "Which messages need this person's attention?"

Temperature 0.1 keeps the model grounded and factual. Every prompt asks for structured JSON output, with robust fallback parsing if the model hallucinates the format.

How the pipeline works

┌──────────┐   ┌───────────┐   ┌────────────┐   ┌──────────┐
│ WhatsApp  │   │   Parser  │   │ Noise      │   │  Chunker │
│ .txt file │──▶│ (Android/ │──▶│ Filter     │──▶│ (smart   │
│           │   │  iOS)     │   │            │   │  windows)│
└──────────┘   └───────────┘   └────────────┘   └──────────┘
                                                      │
                                                      ▼
┌──────────┐   ┌───────────┐   ┌───────────────────────┐
│ Renderer │◀──│  Reducer  │◀──│  Chunk Summarizer     │
│ MD+HTML  │   │  (final   │   │  (Ollama map step)    │
│ + ICS    │   │  digest)  │   └───────────────────────┘
└──────────┘   └───────────┘

The agent that built itself

Here's the wild part: most of this code was written by an AI coding agent. I described the architecture, and the agent wrote the 16+ source files, 10 test files, and the deploy infrastructure — all in a single continuous session.

This is the future of open-source contribution: describe what you want, and let AI handle the implementation while you focus on design, privacy, and architecture decisions.

Why Does Open Innovation Matter?

This project would be impossible without open innovation.

If I had built SlothDigest with a closed API like OpenAI or Claude:

Privacy nightmare — Every WhatsApp message would be sent to a US-based server. Family conversations, payment screenshots, medical discussions — all processed by a third party.
No customization — I couldn't tune the prompts for WhatsApp-specific patterns (Hinglish dates, emoji-heavy texts, voice-message references).
No offline use — No internet at your parents' village house? Too bad. No server connectivity? No digest.
Vendor lock-in — If the API changes pricing or policies, the project breaks.
No experimentation — I tested 4 different models and picked the best one. With closed APIs, you use what they give you.

Open-weight models (Qwen, Llama, Mistral, Gemma) running locally via Ollama make this project possible. The model runs on a $0 inference budget. Your data stays on your laptop. You can audit every single prompt and response.

Open innovation means privacy-first, cost-free, customizable AI that anyone can run, modify, and trust.

My Agent Session

This project was built in a single continuous AI-agent session using Backboard's dev platform. The agent read the project requirements, created the architecture, wrote every line of source code, generated the test suite, built the deploy infrastructure, and assembled this blog post.

The session spanned:

16 source modules (parser, chunker, summarizer, renderer, etc.)
10 test files covering every module
3 output formats (Markdown, HTML, iCalendar)
Web UI with Flask (dashboard, upload, digest viewer, config)
Deploy automation (35+ file assembly from scattered source directories)

The Lazy Payoff

Here's what SlothDigest actually saves you every morning:

Without SlothDigest	With SlothDigest
Scroll through 500+ messages	Read a 2-paragraph digest
15-20 minutes of doom-scrolling	30 seconds of browsing
Miss deadlines in noisy chats	Deadlines extracted to your calendar
Forget to reply to someone who asked you	"Needs you" section catches it
Read ads, forwards, "Good morning!" images	Noise filter drops them automatically

The name "SlothDigest" is a double joke — it works like a slow, thoughtful sloth (deferring work), and it saves you time so you can be the sloth.

Prize Categories

General — Complete, functional open-source AI project -Backboard Studio -Cursor

SlothDigest v0.1.0 — Built with 🦥 in October 2026 for Hacktoberfest.

Bill Box

Akshra Jain — Sat, 17 Oct 2026 17:00:44 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

BillBox is a local invoice and receipt sorter for Indian freelancers and small shop owners.

Every month, someone who files GST has a pile of bills: printed tax invoices, thermal-paper receipts, phone photos, PDFs from vendors. Their CA needs all of it as a clean sheet with vendor, GSTIN, date, taxable amount, and the CGST/SGST/IGST split. Today that means hours of manual typing, or paying someone to do it.

With BillBox you drag in photos or PDFs of your bills. A vision model running on your own laptop reads each one and pulls out the fields. Then the app double-checks the result with plain rules (valid GSTIN format and checksum, taxable + tax = total, duplicate bills, impossible dates). Anything that fails is flagged for a quick human review. When you're done, you export a CSV or an Excel file with a summary sheet and a detailed sheet, ready to hand to your CA.

Who would pay for it: freelancers, small traders, and shopkeepers who deal with GST bills every month and don't want to upload their financial documents to someone else's server. [TODO: add your pricing idea, e.g. a monthly price or one-time license.]

Demo

Code

https://github.com/akshrakothari/Bill-Box

How I Built It

The whole pipeline runs locally, and the open pieces are what make it work:

Model: an open-weight vision-language model, Qwen2.5-VL 7B, served by Ollama. The model name is a config value, so it can be swapped for another open model without touching code. [TODO: update if you used a different model.]
Backend: FastAPI + Pydantic + SQLite. PyMuPDF turns PDF pages into images, and Pillow/OpenCV cleans up photos (rotation, resizing, contrast).
Extraction: each bill goes to the model with a strict JSON schema prompt at temperature 0. The prompt tells the model to return null instead of guessing, and to read Indian dates day-first.
Validation layer: a rule-based checker written in plain Python catches what a language model can get wrong: GSTIN checksum, tax math, CGST = SGST, line items vs. taxable amount, duplicate invoices. This is what makes the output trustworthy enough to pay for.
Frontend: React + Vite + Tailwind with a split review screen (original bill on the left, editable fields on the right, flagged fields highlighted).
Learning from corrections: when the user fixes a vendor's name or category, BillBox remembers it locally and applies it next time.
Benchmark script: a script that runs a folder of bills against a ground-truth sheet and reports per-field accuracy, exact-match rate, and seconds per document.
Results

Metric Local model (Qwen2.5-VL 7B) Closed vision API
Bills tested [N] [N]
Field-level accuracy [X]% [X]%
Fully correct invoices [X]% [X]%
Avg. time per bill [X]s [X]s
Cost per bill ₹0 [X]

[TODO: One or two honest sentences about where it struggles, e.g. handwritten bills or faded thermal receipts.]

Why Does Open Innovation Matter?

Privacy is the product. Invoices contain GSTINs, customer names, and a business's real revenue. Many small business owners are uncomfortable sending that to a third-party API. Because the model runs on their own machine, the pitch is simple: your documents never leave your laptop. It even works with the internet off.

The economics only work with local inference. A bookkeeping tool for small shops has to be cheap. If every page costs money through a closed vision API, the margin disappears as soon as a user uploads a few hundred bills a month. With a local open-weight model, the cost per document is zero, so I can charge a small flat price and still have a business. [TODO: add your measured API cost per bill here.]

No lock-in. I'm not tied to one vendor's pricing, rate limits, or model deprecations. If a better open vision model comes out, I change one config line and re-run my benchmark.

It can be tuned for a niche. Indian invoices have their own quirks: GSTINs, HSN/SAC codes, CGST/SGST/IGST splits, day-first dates, and messy thermal receipts. With open weights, this is a niche I can fine-tune for later, instead of hoping a general-purpose API gets it right.

[TODO: Add one sentence on where the open approach actually beat the closed one in your own comparison, or where it didn't. Judges like honesty.]

My Agent Session

My First User

[TODO: first user story]

Prize Categories
Render

GreenMate AI

Akshra Jain — Thu, 08 Oct 2026 15:55:34 +0000

🌱 GreenMate AI --- AI That Gets You Off the Screen

This is a submission for the Hacktoberfest Open-Source AI Challenge
Week 1: Touch
Grass

What I Built

🌱 GreenMate AI

GreenMate AI is an open-source, AI-powered outdoor activity planner
designed to help people spend less time on screens and more time in
the real world.

Most AI applications encourage users to stay inside an app and interact
with a screen. GreenMate takes the opposite approach: it uses AI to
create a personalized outdoor mission and then encourages the user to
put the phone away and go outside.

The app is designed for students, developers, remote workers, and anyone
who wants a simple push to take a break from screens.

How it works

The user chooses:

😊 Current mood
⏱️ Available time
🚶 Preferred activity
🌱 Difficulty
📍 Outdoor environment/location

GreenMate then uses a locally running open-weight AI model to
generate a personalized mission.

For example:

30-Minute Nature Reset

🚶 Walk for 15 minutes\
🌿 Find 3 different plants\
🐦 Listen for birds\
🌳 Spend 5 minutes observing your surroundings\
📵 Avoid checking your phone for the final 10 minutes

Once the mission starts, the app encourages the user to stop interacting
with the application:

📵 Mission started --- put your phone away and enjoy the outside.

The goal is not to maximize app usage. The goal is to make the screen
the shortest part of the experience.

Who is it for?

GreenMate AI is especially useful for:

🎓 Students who spend long hours studying or coding
💻 Developers and remote workers
📱 People trying to reduce unnecessary screen time
🌳 People who want simple outdoor activity ideas
👨‍👩‍👧 Families looking for small outdoor challenges
🌱 Anyone who wants to reconnect with their surroundings

Demo

🌐 Live Demo

[Add deployed application link here]

🎥 Video Demo

[Add demo video link here]

Suggested demo flow

Open GreenMate AI.
Select Stressed as the mood.
Select 30 minutes.
Select Walking.
Select Easy.
Click Generate My Green Mission.
Show the AI-generated outdoor mission.
Start the mission.
Show the "Put your phone away" screen.
Complete the mission and show XP/badge progress.

Code

GitHub Repository

[Add GitHub repository link here]

The project is open source and structured so that contributors can add:

New outdoor missions
New challenges
New open-weight AI models
Additional languages
Accessibility improvements
Weather providers
Offline features
New map/routing providers
UI improvements
Tests and documentation

How I Built It

GreenMate AI is built as a full-stack application with a strong focus on
open-source AI and local inference.

Technology Stack

Layer Technology

Frontend React + TypeScript
Build Tool Vite
Styling Tailwind CSS
Backend Python + FastAPI
AI Runtime Ollama
AI Model Configurable open-weight model
Database SQLite
Maps Leaflet + OpenStreetMap
Weather Open-Meteo (optional)
Routing Open routing solution such as OSRM
Version Control Git + GitHub

Architecture

                         ┌─────────────────────┐
                         │       User          │
                         │ Mood / Time / Goal  │
                         └──────────┬──────────┘
                                    │
                                    ▼
                         ┌─────────────────────┐
                         │   React Frontend   │
                         │  Mission Interface  │
                         └──────────┬──────────┘
                                    │
                                    ▼
                         ┌─────────────────────┐
                         │    FastAPI Backend  │
                         │   REST API Layer    │
                         └──────┬───────┬──────┘
                                │       │
                  ┌─────────────┘       └──────────────┐
                  ▼                                    ▼
        ┌──────────────────┐                  ┌────────────────┐
        │      Ollama      │                  │     SQLite     │
        │  Local Inference │                  │ User Progress  │
        └────────┬─────────┘                  └────────────────┘
                 │
                 ▼
        ┌──────────────────┐
        │ Open-Weight Model│
        │ Mission Planning │
        └──────────────────┘

AI Workflow

The AI is not used as a generic chatbot.

Instead, the application sends structured preferences to the local
model:

Mood: Stressed
Time: 30 minutes
Activity: Walking
Difficulty: Easy
Environment: Park

The model generates structured mission information such as:

{
  "title": "30-Minute Nature Reset",
  "duration_minutes": 30,
  "difficulty": "Easy",
  "activity_type": "Walking",
  "steps": [
    "Walk for 15 minutes",
    "Find three different plants",
    "Observe your surroundings for five minutes",
    "Complete a five-minute return walk"
  ],
  "challenges": [
    "Find something yellow",
    "Listen for three different sounds",
    "Stay screen-free for ten minutes"
  ],
  "screen_free_minutes": 25
}

The structured response makes the AI output predictable and easy for the
frontend to display.

Local AI

The core AI functionality is designed around Ollama and an open-weight
model.

This means the project can run AI locally instead of requiring a
proprietary AI API for the core mission-generation feature.

The model is configurable so that users can experiment with compatible
open-weight models.

Why Does Open Innovation Matter?

Open innovation is particularly important for GreenMate AI because the
project is designed to work close to the user rather than keeping their
information inside a remote AI service.

🔐 1. Privacy

GreenMate can run the core AI locally.

A user's preferences do not need to be sent to a proprietary AI provider
just to generate an outdoor activity.

Location is also treated separately from the AI generation process so
that precise location information does not need to be sent to the AI
model.

🧩 2. Model Choice

With an open-weight approach, users can choose or replace the model
instead of being permanently tied to one proprietary provider.

This makes experimentation easier for students and developers.

🛠️ 3. Customization

The model and prompts can be adapted for different use cases.

For example, contributors could create versions focused on:

Hiking
Gardening
Bird watching
Running
Cycling
Nature photography
Family activities
Local-language outdoor missions

🌐 4. Community Contribution

Because the project is open source, contributors can improve the
application without needing access to a private AI platform.

Someone could contribute a new model adapter, another person could
improve the mission-generation prompt, and another could add
accessibility or multilingual support.

💻 5. Local and Offline Possibilities

A local model makes it possible to explore an important idea:

What if an AI outdoor assistant could continue working even when
internet connectivity is limited?

This is especially relevant for hiking, rural areas, parks, and outdoor
environments.

🔓 6. Transparency

Using open technologies makes the architecture easier to inspect and
understand.

As a B.Tech CSE project, this also makes the system valuable from an
educational perspective because students can learn how:

Frontend
   ↓
Backend
   ↓
Local AI Runtime
   ↓
Open-Weight Model
   ↓
Structured AI Output

actually works.

The Touch Grass Philosophy

GreenMate is intentionally designed around a slightly unusual product
principle:

The best session is the session where the user leaves the app.

Most applications optimize for:

More clicks
More sessions
More screen time
More engagement

GreenMate optimizes for:

More outdoor time
More movement
More observation
More screen-free minutes
More connection with the real world

The application therefore has an intentional "exit the app" moment.

After starting a mission, the user sees:

🌱 YOUR MISSION HAS STARTED

📵 Put your phone away.

Go outside.
Complete your mission.
Enjoy the real world.

We'll be here when you return.

Privacy & Safety

GreenMate is designed with privacy and responsible use in mind.

Privacy principles

Local AI is preferred for the core AI functionality.
Precise location is not required for AI mission generation.
Location access requires explicit user permission.
Sensitive location information should not be unnecessarily stored.
API keys should never be committed to the repository.
Environment variables are used for configuration.

Safety principles

GreenMate should:

Recommend realistic activities.
Avoid dangerous activities.
Avoid encouraging users to enter restricted or private areas.
Avoid medical diagnosis or medical claims.
Consider weather when weather data is available.
Encourage users to follow local safety rules.
Provide fallback suggestions when location or routing services are unavailable.

My Agent Session

<!-- Optional. Add your DevRelay agent session here if available. -->

[Add DevRelay agent session link here]

Prize Categories

<!-- Add the applicable partner prize categories here after checking the challenge page. -->

[ ] Partner Category 1
[ ] Partner Category 2
[ ] Partner Category 3

Project Roadmap

✅ MVP

[x] Project concept
[x] Open-weight/local AI architecture
[x] Personalized outdoor mission generation
[x] Mood and time-based activity planning
[x] Screen-free mission concept

🚧 In Development

[ ] React frontend
[ ] FastAPI backend
[ ] Ollama integration
[ ] Structured AI responses
[ ] Leaflet/OpenStreetMap integration
[ ] SQLite progress tracking
[ ] Gamification
[ ] Offline fallback

🔮 Future Scope

📱 Android/iOS application
🎙️ Voice-based mission generation
👁️ Local vision model for plant recognition
🐦 Bird identification
⌚ Smartwatch integration
🌐 Multilingual support
🗺️ Better offline maps
🧠 Personalized local models
👥 Community-created outdoor challenges
♿ Improved accessibility

What I Learned

Building GreenMate AI helped me explore several areas of computer
science:

Full-stack application development
REST API design
Local AI inference
Open-weight AI models
Prompt engineering
Structured AI output
Privacy-aware application design
Maps and geolocation
Database design
Git and GitHub workflows
Open-source contribution practices

Most importantly, the project changed the way I think about AI.

AI does not always have to make us spend more time with technology.

Sometimes the best use of AI is to help us put the technology down.

Conclusion

🌱 GreenMate AI

AI that gets you off the screen and into the real world.

GreenMate AI combines open-weight AI, local inference, maps, and
gamification to create a simple goal:

Use AI → Start a mission → Put the phone away → Go outside.

The project is built with open technologies so that developers and
students can inspect it, modify it, replace the AI model, and contribute
new ideas.

Because sometimes, the smartest thing an AI can tell you is:

📵 Put your phone away. Go touch grass. 🌱

Team

Project: GreenMate AI

Team Members:

[@YOUR_DEV_USERNAME] --- Developer / AI / Project Lead
[@TEAMMATE_USERNAME] --- [Role]
[@TEAMMATE_USERNAME] --- [Role]

<!-- For a team submission, list the DEV usernames of all teammates here. -->

License

This project is open source.

License: [Add your chosen open-source license, e.g. MIT]

“My family doesn't need another AI chatbot. They need one place to remember the things they keep telling each other.”

Akshra Jain — Fri, 02 Oct 2026 09:33:28 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

DEV Community: Akshra Jain

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

What I Built

Demo

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

What I Built

Demo

SlothDigest — A Local-First AI Agent for Your Morning WhatsApp Digest

What I Built

Demo

Code

Quick start

Architecture at a glance

Key design decisions

How I Built It

The open-source AI stack

How the pipeline works

The agent that built itself

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

Bill Box

GreenMate AI

🌱 GreenMate AI --- AI That Gets You Off the Screen

What I Built

🌱 GreenMate AI

How it works

Who is it for?

Demo

🌐 Live Demo

🎥 Video Demo

Suggested demo flow

Code

GitHub Repository

How I Built It

Technology Stack

Architecture

AI Workflow

Local AI

Why Does Open Innovation Matter?

🔐 1. Privacy

🧩 2. Model Choice

🛠️ 3. Customization

🌐 4. Community Contribution

💻 5. Local and Offline Possibilities

🔓 6. Transparency

The Touch Grass Philosophy

Privacy & Safety

Privacy principles

Safety principles

My Agent Session

Prize Categories

Project Roadmap

✅ MVP

🚧 In Development

🔮 Future Scope

What I Learned

Conclusion

🌱 GreenMate AI

📵 Put your phone away. Go touch grass. 🌱

Team

License

Links

“My family doesn't need another AI chatbot. They need one place to remember the things they keep telling each other.”

FamilyBoard AI 🏠

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Intro