DEV Community: PARITOSH

Sloth Mode: open-weight AI that does the chores, and a journal that undoes them

PARITOSH — Tue, 20 Oct 2026 16:09:55 +0000

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

What I Built

Sloth Mode is a command-line tool (with a small local web GUI) that runs an
open-weight model you host yourself and points it at three jobs everybody
postpones:

sloth tidy — reads your junk-drawer folder, proposes a home and a better name for every file, and shows you the plan. Nothing moves until you say so.
sloth brief — reads an overnight pile of group chats and hands back two sentences plus the things that actually need you.
sloth fridge — one photo of the fridge, door closed, becomes a shopping list.

$ sloth tidy ~/Downloads

Admin/Invoices/
  ACME Invoice March 2024.pdf   → acme-invoice-march-2024.pdf   [model 99%]

Reading/Notes/
  notes.txt                     → garden-boiler-notes.txt       [model 85%]

_Unsure/
  thing.qqq                                                     [model 30%]

dry run. re-run with --apply to move these files.

Two details carry the whole design. notes.txt became garden-boiler-notes.txt
because the model read the file. And thing.qqq went to _Unsure at 30%
rather than to a confident-looking wrong folder — "I don't know" is a valid
answer, and the threshold enforces it.

Demo

Code

Pager-dot / sloth-mode

Local open-weight AI that does your chores while you nap. Zero dependencies, nothing leaves your machine.

      (
       \     ___
        \  .'   `.        s l o t h   m o d e
         \/  o o  \       ----------------------
         (   \_/   )      it does the work
          \  ---  /       you do the nap
       ,--' )   ( `--.
      (___.'     `.___)

Local, open-weight AI for the chores you keep putting off.

Zero dependencies. Runs on Gemma. Local by default.

Why · Install · The agents · The GUI · How it works · Config · Safety

Real run against gpt-oss:120b. Plan → Apply → Undo → morning brief, 22 seconds. 📺 Watch the full video · download the MP4

Why

Sloths are not lazy, they are efficient. They do the minimum that keeps them alive and spend the rest of the day not wasting energy. That is a design principle, not a personality flaw.

sloth is a command line tool that applies it to your computer. It runs an…

View on GitHub

How I Built It

The open pieces are not decoration — they are the engine.

Open piece	What it does here
Gemma 3 (`gemma3:4b`)	the local default; multimodal, so one 3 GB pull covers all three agents
gpt-oss:120b (Apache-2.0)	120B parameters via Ollama Cloud, no GPU, no download
Gemma 4 (`gemma4:31b`)	the vision model behind `fridge`
Ollama / llama.cpp / vLLM / LM Studio	inference, your choice of host
Hugging Face Inference Providers	the same open weights on a free tier
The Python standard library	the only dependency

Zero runtime dependencies is itself a laziness feature: pip install and you are
done. urllib talks to the model, http.server serves the GUI, tomllib reads
the config, and the undo journal is JSONL you can read with tail.

Four backends sit behind one Model protocol, so --api cloud, --api hf or a
bare local Ollama are one flag apart. I wrote a small agent harness
(~250 lines) rather than pulling in a framework: tools are plain functions with a
JSON-schema argument spec, the loop is bounded by steps and a wall clock, and
every tool is read-only unless writes are explicitly allowed. An agent can
look at anything and propose anything; only the apply step touches the disk.

The spine of the whole thing is: the model is never trusted.

It can only choose from your configured taxonomy. Invent Vibes/Whatever and the answer is discarded for a keyword/extension heuristic.
It cannot change a file extension.
It cannot escape the root directory with a ../../../etc/passwd filename.
Below the confidence threshold, nobody guesses.
And if no model is running at all, every agent except fridge still works on heuristics — fridge says so instead of inventing a shopping list.

Then I ran it against a real model, and four things broke

I had 189 passing tests before the first real inference call. All green. Here is
what they had failed to notice:

1. The JSON schema was being ignored outright. Every call ships one. I
assumed it was honoured. It is not — I measured it: a request carrying a schema
that requires {"ok": boolean}, with a prompt asking for prose, came back as
'Sloths move slowly through the treetops...'. Not loosely enforced. Ignored.

2. So the morning brief silently degraded. The model answered the map step
with {"action_items": [...]} where the schema said {"points": [...]}. My code
read only the expected key, got an empty list, and fell back to keyword
extraction — while printing "no model running" with a 31B model very much
running. A silent failure that looks like success is worse than a crash.

3. --deep was 100% dead. gpt-oss writes its entire planned trajectory as
several JSON objects in one reply. The parser raised Extra data, the harness
retried four times, hit max steps, and returned nothing. Every unsure file, every
run, invisibly.

4. fridge dropped every item it saw — the model answered [{"item": "milk"}]
where the schema said name, so the shopping list cheerfully told you to buy the
milk that was visible in the photo.

Same root cause, four faces. The fix was to stop treating the schema as a
contract: accept the field under another name, unwrap markdown fences, take the
first complete JSON value, state the shape in the prompt as well, and force the
summary into the sentence count that was asked for. The suite is now 250 tests
that need no weights and no network — a FakeModel for logic, a throwaway HTTP
server for the wire format.

Why Does Open Innovation Matter?

Because I could measure the thing instead of believing it.

That schema discovery is the entire argument. Against a closed API I would have
read the docs, seen that structured output is supported, and shipped a brief that
quietly produced keyword slop for a subset of users. What let me find it was that
every layer was inspectable: I could send a byte-identical request with a valid
schema, a deliberately bogus schema, and no schema at all, diff the three
replies, and know. Then I could fix it in my own parser. No ticket, no waiting
for a vendor, no "we don't comment on model internals."

Open weights let the work happen where the files already are. The entire
value proposition — tidy the folder full of invoices and contracts — collapses if
step one is "upload your invoices and contracts." Running locally is not a
privacy feature bolted on; it is the only reason the tool is usable by the people
who need it most. The tool is honest about the trade, too: pick a hosted backend
and sloth doctor prints prompts are sent to https://ollama.com in yellow,
every single run.

The open ecosystem converged on two wire formats, so swapping is one flag.
Gemma 3 on a laptop, gpt-oss:120b in the cloud, anything on a llama.cpp server —
the same code, because /api/chat and /v1/chat/completions are conventions
anyone can implement. That is also an honest escape hatch: nothing here is
load-bearing on one vendor's continued goodwill or pricing.

And it scales down to nothing. gemma3:1b runs on almost any machine.
--no-model runs on none at all. A tool built on a closed API has a hard floor:
no key, no product. This one degrades to keyword heuristics and keeps working on
a train with no signal — which is, after all, the most sloth-like property
available: it does not even need the internet to be awake.

LedgerLocal - your receipts never leave your laptop

PARITOSH — Fri, 16 Oct 2026 16:39:32 +0000

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

What I Built

LedgerLocal — a CLI that turns a freelancer's folder of invoices and receipts into a sorted, accountant-ready archive, entirely on their own laptop.

Point it at a folder: it reads each document with a local vision model, extracts vendor / date / tax / currency / total, categorises it against rules you control, files it into a year/quarter/category tree, and exports the CSV your accountant asks for.

Who pays: freelancers and one-person studios with 300 unsorted receipts and a lost weekend every tax season. Plenty of SaaS does this — all of it wants the documents uploaded. Receipts name your clients, expose your rates, and carry card digits and tax IDs. For consultants under NDA or anyone under data-residency rules, uploading isn't a price question, it's a non-starter. Their real choice is local tool vs. the weekend.

The best part isn't extraction, it's distrust: every document is audited after the model answers. In the demo the model misreads $65.09 as $65.00 and the tool catches it from the arithmetic — nobody told it to look.

Demo

Code

Pager-dot / ledgerlocal

Local-first invoice & receipt sorter for freelancers, powered by open-weight models.

LedgerLocal

Sort a year of invoices and receipts into a clean, accountant-ready archive — on your own laptop, with an open-weight model, with no network access at all.

Point it at the folder where your receipts pile up. It reads each one with a local vision model, pulls out vendor, date, tax and total, categorises it against rules you control, files it into a sane folder tree, and exports the CSV your accountant actually wants.

$ ledgerlocal ingest ~/Downloads/receipts
  read    hetzner-feb.pdf
  read    coffee-with-northwind.jpg
  read    adobe-jan.pdf
  read    legal-invoice.pdf

  2026-02-14  Hetzner Online GmbH             32.73 EUR  hosting
  2026-04-03  Blue Fox Coffee                 11.77 EUR  meals
  2026-01-07  Adobe Inc.                      65.00 USD  software      review
  2026-03-02  Bright Path Legal LLP          990.00 USD  professional_fees

4 ingested, 0 already known, 0 failed, 1 need review

$ ledgerlocal review

1 document(s) the pipeline is not confident about:

  2026-01-07  Adobe Inc.                       65.00 USD
      · subtotal + tax differs from total

…

View on GitHub

How I Built It

Open-weight models: Qwen2.5-VL 7B (photos, scans) and Qwen2.5 7B (text-layer PDFs), served locally by Ollama.
Two local runtimes: a three-method provider interface with an Ollama client and an OpenAI-compatible one (llama.cpp, vLLM, LM Studio). Swapping models or pointing at a fine-tune is one config line.
Schema-constrained decoding is load-bearing — the JSON schema goes to the runtime itself, so the model physically can't emit malformed JSON. Available because I control the decoder.
The model never formats anything. It finds the total; Python decides "1.234,56 €" is Decimal("1234.56"). Small models are good at finding, unreliable at formatting.
Audit, then one repair pass. Subtotal + tax must equal total; failures go back to the model with the specific complaint, best answer wins.
Zero required dependencies — the whole model client is stdlib urllib against localhost. When the pitch is "audit this yourself," a 40-package tree undermines it.

SQLite keyed on content hash (re-running a folder is a no-op). ~3,600 lines, 89 tests, no GPU or network needed. Apache-2.0: github.com/Pager-dot/ledgerlocal

Why Does Open Innovation Matter?

The headline feature is one a closed API cannot ship. Rather than ask users to trust a privacy policy, I removed the capability. Every command installs a process-wide socket allowlist first:

socket.create_connection(("api.openai.com", 443))  # OfflineViolation
socket.create_connection(("127.0.0.1", 11434))     # fine — that's your model

A hosted version can't implement this, because the egress it blocks is the call the product depends on. Not a cheaper substitute — a product that otherwise can't exist.

Unmetered inference changed the engineering, not just the bill. The repair pass runs on every uncertain document; on a metered API you'd ration that. recategorise replays three years of documents against new rules in under a second with zero model calls — there's a test asserting the provider is never touched. With per-document pricing you simply don't change your mind, and the rule system dies unused.

Swappability is leverage you keep. A 3B on battery, a 32B at year-end, a LoRA fine-tuned on one client's bizarre invoice layout. With a closed API that last one is a feature request to a vendor who'll never prioritise it.

Where closed wins, honestly: a frontier model reads a crumpled thermal receipt better than a 7B. I closed most of that gap with structure instead of scale — constrained decoding, deterministic parsing, arithmetic audits — and surfaced the rest in a review queue. The discipline a small model forced made a better product, because a frontier model would have tempted me to skip the checks.

Checking AQI Instead of Doomscrolling: My Laptop's New Job Is Getting Me Outside

PARITOSH — Sat, 10 Oct 2026 02:59:28 +0000

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

What I Built

AeroVision is an AI-powered air quality app that answers one question before you walk out the door: is it actually safe to be outside right now?

It has two parts:

An AQI predictor trained on 5+ years of pollution data from 26 Indian cities (29,531 records). Give it pollutant concentrations (PM2.5, PM10, NO2, CO, etc.) and it predicts the Air Quality Index and health category using four different ML models (Random Forest, XGBoost, Gradient Boosting, Extra Trees) side by side.
A live AQI view — the part that actually gets you outside. Search any city (or use your current location), and it pulls real-time pollutant data, runs it through the trained model, and shows you the current AQI, a 24-hour forecast, and current weather — so you can decide when in the next day is actually the best window to go for a run, walk the dog, or just open the windows.

It's for anyone living somewhere air quality swings hard day to day — which, if you've spent time in Delhi, Ahmedabad, or Patna during peak pollution season, is most of India. Instead of guessing from haze outside your window, you get a number and an actual forecast window.

Demo

https://youtu.be/MDjNqBvu1vM

Code

Pager-dot / AeroVision

AI-Powered Air Quality Index Prediction & Monitoring System

AeroVision - AI-Powered Air Quality Prediction & Monitoring System

A machine learning web application that predicts Air Quality Index (AQI) from pollutant concentrations and provides interactive dashboards to monitor air pollution trends across 26 Indian cities.

Built with Flask, scikit-learn, XGBoost, Bootstrap 5, and Chart.js.

Problem Statement

Air pollution is one of the most critical environmental challenges in India. Cities like Delhi, Ahmedabad, and Patna frequently experience hazardous pollution levels, directly impacting public health.

Goal: Build a system that can:

Predict the AQI value given pollutant concentrations (PM2.5, NO2, CO, etc.)
Classify the predicted AQI into…

View on GitHub

How I Built It

AeroVision is built around open-source ML, not a closed API:

scikit-learn (Random Forest, Extra Trees, Gradient Boosting) and XGBoost for the actual AQI prediction — all trained locally on an open dataset (Kaggle's Air Quality Data in India), with the full pipeline (cleaning, IQR outlier removal, StandardScaler, train/test split) transparent and reproducible in train_model.py.
Flask serves the models and the live view.
For live readings, I use OpenWeatherMap's free Air Pollution API to get real pollutant concentrations for any city, then feed those straight into the same trained model — so live, real-world air quality gets scored on the same scale as the historical dataset, not just OpenWeather's own 1-5 index. The app shows both side by side.

The model itself has no dependency on any proprietary AI service — the entire prediction pipeline is open-source, inspectable, and retrainable by anyone who clones the repo.

Why Does Open Innovation Matter?

Because this is a public-health tool, not a toy. If the model were hidden behind a closed API, nobody could check why it predicted what it predicted, retrain it on their own city's data, or catch bias in it (e.g. is it systematically off for cities with sparse data?). Open tooling means:

Anyone can see exactly how AQI is derived from raw pollutants (train_model.py is the whole pipeline, no black box).
Anyone can swap in their own country's dataset and retrain — this doesn't have to be India-only.
No API cost or rate-limit wall stands between someone and a decision that affects their health today.

Spend Review: I read my friend's bank statement so she never has to

PARITOSH — Sat, 03 Oct 2026 16:25:54 +0000

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

What I Built

I built this for my friend Sagrika, who spends like the money is not real and then
arrives at the end of the month genuinely puzzled about where it went. Not reckless,
exactly just a hundred small decisions that never felt like decisions, and no way to
see them stacked up. Her bank sends her a statement every month. She has never once
read it, and having now read one myself, I understand why.

Every Indian bank hands you a statement and calls it insight. HDFC's is a 342-row
.xls where the first 20 rows are your address, the transaction you care about is
described as UPI-SOMTHING HOSPITALITY PVT-Q6245659728@YBL-YESB0YBLUPI-645845694696-PAID VIA SUPERMONEY, and nothing anywhere tells you that you spent ₹6,755 on food.

The usual fix is to upload the statement to a budgeting site. That is the part I
would not do. A bank statement is a complete record of where you were and who you
paid for six months — it is not a file to hand to a free web service in exchange for
a pie chart.

Spend Review is a single-file Streamlit app that reads the statement, finds the
real transaction table inside the bank's formatting, and sorts six months of spending
into 14 categories. It holds nothing. The file is parsed in memory and gone when you
close the tab.

Upload, and you get:

Total spent, total received, transaction count
Spend per category with each category's share
Top 20 payees, with the bank's narration string cleaned into an actual name
A filterable table of every transaction, downloadable as CSV

That's the whole app. It doesn't set budgets, it doesn't send reminders, and it will
never tell her to stop buying things. It just makes six months of small decisions
visible in one screen, which turns out to be the part that was missing.

Demo

Hosted demo: https://spend-review.onrender.com

Free tier, so the first load takes about a minute while the service wakes up — give it
a moment before deciding it's broken. Nothing you upload is stored, by the service or
by me; the file is parsed in memory and dropped when you close the tab.

In the recording: six months of an HDFC statement goes in as the bank exported it,
342 rows of letterhead and footer and all, and 294 categorised transactions come out.
The surprise is not the food row. It's that the subscriptions row is more than twice
as large, spread over fourteen charges small enough that none of them ever felt like
spending money.

Code

Pager-dot / spend-review

Streamlit app that categorises HDFC bank statement spending

Spend Review

A small Streamlit app that reads an HDFC Bank account statement (.xls / .xlsx) and groups the transactions into spending categories.

Live demo: https://spend-review.onrender.com — free tier, so the first load takes about a minute while the service wakes up. Nothing you upload is stored.

Run locally

pip install -r requirements.txt
streamlit run app.py

Then upload your statement in the browser.

What it shows

Total spent, total received, transaction count
Spend by category, with each category's share
Top payees
A filterable transaction table, downloadable as CSV

Privacy

Uploaded statements are parsed in memory and never written…

View on GitHub

How I Built It

Streamlit, pandas, and about 200 lines of Python. No model, no API, no database. The
interesting parts were all in the data.

Why Does Open Innovation Matter?

The honest version of my answer is that open innovation let me not use an API at all.

It costs nothing and cannot be taken away. No key, no account, no quota, no
pricing-page change in eighteen months. pip install -r requirements.txt and it runs,
today or in five years, with the Wi-Fi off. Free-tier API keys are the one component
of a weekend project most likely to be dead before anyone else tries to run it.

My Agent Session

Built in an evening with Claude Code. The useful division of labour turned out to be
that it did the archaeology and I did the judgement calls.

It opened the .xls, found the header at row 20, worked out that xlrd was required,
built the keyword rules from the actual narration strings in my statement rather than
from a guess about Indian merchants, and caught the $PORT binding issue before the
first Render deploy instead of after it.

Two moments worth recording. When I asked it to make a public repo it checked what was
staged and grepped the committed history for my account number and card digits before
pushing — the statement was gitignored, but it verified rather than assumed. And when I
said "make sure nothing is stored", it came back with the cache_data decorator it
had itself added two steps earlier, and explained why that was the one thing in the app
that broke the promise. I would not have found that.

Prize Categories

Best Use of Render

DEV Community: PARITOSH

Sloth Mode: open-weight AI that does the chores, and a journal that undoes them

What I Built

Demo

Code

Pager-dot / sloth-mode

Local open-weight AI that does your chores while you nap. Zero dependencies, nothing leaves your machine.

Why

How I Built It

Then I ran it against a real model, and four things broke

Why Does Open Innovation Matter?

LedgerLocal - your receipts never leave your laptop

What I Built

Demo

Code

Pager-dot / ledgerlocal

Local-first invoice & receipt sorter for freelancers, powered by open-weight models.

LedgerLocal

How I Built It

Why Does Open Innovation Matter?

Checking AQI Instead of Doomscrolling: My Laptop's New Job Is Getting Me Outside

What I Built

Demo

Code

Pager-dot / AeroVision

AI-Powered Air Quality Index Prediction & Monitoring System

AeroVision - AI-Powered Air Quality Prediction & Monitoring System

Table of Contents

Problem Statement

How I Built It

Why Does Open Innovation Matter?

Spend Review: I read my friend's bank statement so she never has to

What I Built

Demo

Code

Pager-dot / spend-review

Streamlit app that categorises HDFC bank statement spending

Spend Review

Run locally

What it shows

Categories

Privacy

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories