DEV Community: Aryan Raj

Loafer: Let a Local Model Read Your Chats While You Sleep

Aryan Raj — Sat, 24 Oct 2026 06:34:52 +0000

What I Built

I built Loafer, a local-first CLI that reads chat and email exports while I sleep and turns them into a short morning digest.

Instead of reopening several apps and scanning hundreds of messages, I point Loafer at a folder and get:

a two-line summary,
a checklist of promises and requested actions,
a per-thread breakdown,
source file and line references for the checklist items,
and a nag command for promises that keep appearing across days.

It also has an ask command for questions over the local corpus and a grocery command that turns a fridge photo into a conservative shopping list.

The person who gets to be lazier is the person who has to remember everything from every group chat. Loafer does the first pass. The human only checks the few lines that matter.

Demo

Repository: https://github.com/Aryan1092raj/Sloth

The project runs from a terminal with no web account or hosted service:

python3 -m loafer digest --backend heuristic --input examples --out ~/loafer/digests
python3 -m loafer todo
python3 -m loafer ask "what did we promise about the invoice?"
python3 -m loafer nag

The fastest demo uses the included examples/ folder and the standard-library fallback, so it works even when no model server is running. For the full demo, I run the same commands with Ollama and an open-weight model.

Code

The complete source is in the repository:

https://github.com/Aryan1092raj/Sloth

The project is intentionally small and dependency-free. The main flow lives in:

loafer/collect.py for safe local file collection,
loafer/digest.py for chunking, analysis, provenance, and Markdown rendering,
loafer/llm.py for Ollama and llama.cpp backends,
loafer/fallback.py for extractive no-model operation,
loafer/watch.py for incremental overnight processing,
loafer/ask.py for local BM25 retrieval,
loafer/todo.py and loafer/history.py for the follow-up loop.

The test suite runs with Python's standard library. The current suite has 49 passing tests.

How I Built It

Loafer uses open-weight models through local Ollama or an OpenAI-compatible llama.cpp server. The model is a replaceable component, not a hosted dependency.

The pipeline is:

Scan a folder for text exports while skipping hidden directories, virtual environments, generated files, and the output folder.
Split long conversations into overlapping chunks so the end of a thread does not disappear silently.
Ask the local model for structured JSON containing a summary, actions, topics, and a rough content type.
Fall back to an extractive summarizer and cue-based action detector when no model is installed or a model returns invalid JSON.
Merge the results into a Markdown digest that can be read, searched, copied into another tool, or checked off.
Match each extracted action back to the strongest source line when possible, producing references such as team-chat.txt:L9.

The overnight watch command remembers file size and modification time, uses inotify on Linux when available, and falls back to polling elsewhere. It only reprocesses new or changed files.

The project also has a privacy guard: Loafer refuses to send data to a non-local host unless the user explicitly opts in with LOAFER_ALLOW_REMOTE=1.

Why Does Open Innovation Matter?

The input is private by default: messages with friends, client emails, deadlines, and household photos. A cloud assistant would require sending that material to someone else's server and would usually require an account, an API key, or a paid quota.

Loafer keeps the model on the user's machine. After the model is installed, the workflow can run offline, costs nothing per digest, and leaves the exports on disk. Users can swap models, serve their own fine-tuned weights, inspect the prompts, or use the pure-Python fallback when they do not want to run a model at all.

Open innovation also makes the failure mode visible. If the model produces a bad action, the digest points back to the source file and line instead of pretending the summary is authoritative.

My Agent Session

The Lazy Payoff

The main payoff is not that Loafer writes a nicer summary. It removes the need to reread every thread.

In the repository's documented benchmark, 20 exports took about 11.8 seconds with qwen3:0.6b on an RTX 4050. The no-model heuristic path took about 0.07 seconds. The user then opens one Markdown file and sees the small set of actions worth checking.

The new line-level references make that loop faster again: when a task looks questionable, I can jump straight to the sentence that produced it instead of searching the whole export.

Prize Categories

I am entering the main Slow and Steady challenge. I am not claiming a partner category unless I add and document that partner's technology in the final demo.

Disclosure

I used AI assistance while building and editing this project, then reviewed the code, tests, and claims before preparing this submission.

ScopeShield: Stop Working for Free — NDA-Safe Scope-Creep Auditor

Aryan Raj — Sun, 18 Oct 2026 09:23:28 +0000

Target DEV title: ScopeShield: I Stopped Working for Free with Gemma + TabPFN (and Kept Client Data Off Closed APIs)
Tags: devchallenge, hf26challenge, ai, opensource
Challenge: Hacktoberfest Week 2: Side Hustle — closes Oct 18, 2026 11:59 PM PDT

What I Built

ScopeShield — NDA-Safe Freelance & Boutique Agency Scope-Creep Auditor and Change-Order Engine.

Freelancers and 2-10 person agencies lose 15-28% of gross revenue to unbilled scope creep:

Signed 12-15 page SOW says "3 revision rounds, React frontend, no DevOps."
Client Slacks: SSO, Hindi locale pack, K8s hotfix, "just one more revision."
You do it to be nice. You never invoice it. You eat $1,800 that week.

Upload SOW PDF/Markdown + weekly CSV (Jira/Linear/GitHub/Toggl) → line-by-line ledger with IN_SCOPE / GREY_AREA / OUT_OF_SCOPE + clause citations + recoverable $ + one-click change order + polite email grounded in live market rates.

Who pays? Solo freelancer Priya + micro-agency owners defending overages to client finance. $19/mo solo — viable because open weights make marginal token cost $0. One saved 4h ticket at $70/h pays 14x.

Verified offline (10/10 tests green, no keys): 53.0h logged → 26.0h out-of-scope → $1,845 recoverable across 12 rows, 4 leaks:

JIRA-105 SSO + audit logs 11h → Section 5.2 Exclusion — $770 (leak 0.909)
JIRA-106 Hindi locale pack 6h → Section 7.1 Exclusion — $450 (leak 0.915)
JIRA-107 Prod K8s hotfix 5h → Section 7.1 Exclusion — $425 (leak 0.887)
JIRA-108 Hero 5th revision 4h → Section 4.2 Revision Policy — $200

Demo

1-click judge path, no upload:

make setup && make test   # 10/10 green
make api  # uvicorn :8000 → GET /api/demo/audit
make web  # vite :5173 → Run Real Agency Audit

GET /api/demo/audit — full pipeline on bundled SOW (14 clauses) + CSV (12 rows)
GET /api/demo/ledger.csv — finance-ready export
GET /api/health — tiger/tabpfn/gemma/serp status
UI: Upload → traffic-light ledger → editable change order + Copy Email + Download + telemetry drawer

Links:

Repo: https://github.com/Aryan1092raj/ScopeShield

Local demo is the source of truth — no hosted deploy.

GIF checklist: ledger with 4 red pills → expand JIRA-105 §5.2 quote → email preview → telemetry JSON.

Code

Repo: https://github.com/Aryan1092raj/ScopeShield (main, MIT)

On DEV embed with:

Aryan1092raj / ScopeShield

🛡️ ScopeShield — NDA-Safe Scope-Creep Auditor

Tagline: Stop working for free. Turn SOWs + work-logs into paid change orders Domain: scopeshield.tech (Render Static + FastAPI backend) Theme fit: DEV Side Hustle — open-source AI at its core that someone would pay $19/mo for.

0. Quickstart (code phase — verified)

make setup          # pip + npm install
make test           # 7/7 green: 4/4 leaks, $1845, $26h OOS
make bench          # Tinker 250+50 pairs → validity/F1 table
make api            # uvicorn :8000 → GET /api/demo/audit
make web            # vite :5173 → Run Real Agency Audit

Verified numbers: 53.0h logged → 26.0h out-of-scope → $1,845 recoverable (JIRA-105/106/107/108). Frontend npm run build clean (1.25s, 1569 modules).

Live repo: https://github.com/Aryan1092raj/ScopeShield — main tracks origin/main.

Deploy (Render + .tech)

# 1. Tiger Data: run README §7.1 DDL, then:
psql $DATABASE_URL -f scripts/seed_tiger.sql
# 2. Render: New → Blueprint → point at render.yaml (api + static

…

View on GitHub

scopeshield/
├── backend/main.py audit_service.py sow_parser.py db_tiger.py
│           engine_tabpfn.py engine_serp.py engine_gemma.py schemas.py test_audit.py
├── data/demo_sow_contract.md demo_weekly_git_jira.csv baseline_agency_tickets.csv
├── scripts/generate_tinker_dataset.py benchmark_tinker.py seed_tiger.sql
└── frontend/ React 19 + Vite + Tailwind ledger UI

Hybrid RRF SQL (Tiger Data, README 7.1, no LangChain):

SELECT c.section_number, c.clause_text, c.is_exclusion_clause,
  COALESCE(s.dist, 1.0)::FLOAT AS semantic_distance,
  (COALESCE(1.0/(rrf_k+s.rank_ix),0.0)+COALESCE(1.0/(rrf_k+k.rank_ix),0.0))::FLOAT AS rrf_score
FROM semantic_search s FULL OUTER JOIN keyword_search k USING (clause_id)
JOIN sow_clauses c ON c.clause_id = COALESCE(s.clause_id, k.clause_id)
ORDER BY rrf_score DESC LIMIT 3;

Local fallback match_memory() mirrors the fusion so demo works with zero infra.

How I Built It

Every sponsor tech has a non-overlapping job:

Tiger Data (pgvector + tsvector, RRF pure SQL): SOW chunked by Section X.Y, 768-d via nomic-embed-text local via Ollama, top-3 clauses per row.
TabPFN-3.5 (tabpfn-client): 9-feature vector per row to predict_proba to scope_leakage_probability. LLMs hallucinate math, TabPFN does not. Heuristic fallback when no key.
Gemma 2 9B-IT (open weights via Ollama/vLLM) + Tinker LoRA: strict-JSON verdict + citation + email/order. 250+50 pairs via generate_tinker_dataset.py, benchmark_tinker.py reports validity/F1/tokens. Adapter gemma-2-9b-tinker-sow-v1. Stub judge for offline CI, Ollama path with repair retry for real Gemma.
SerpApi: freelance {category} rate 2026 to regex median + 24h cache + fallback table (frontend 55, backend 70, devops 85, design 50, compliance 90, database 75).
Sentry: ScopeShield_Full_Audit transaction + 4 spans (Tiger/TabPFN/SerpApi/Gemma), trace id in UI drawer. Local-first — no hosted deploy.
Entire / Copilot: session export for appendix.

Pipeline per row (audit_service.py): index clauses to match_memory/match_tiger to build_feature_row to score_rows to fetch_market_rate to judge_row_stub/judge_row_ollama to totals + change-order markdown + client email.

Tinker honesty: dataset + harness shipped, stub simulation shows validity +25pp / F1 +0.15 / tokens -35% directionally. Full GPU LoRA next, contract frozen and reproducible.

Why Does Open Innovation Matter?

NDA-safe: Gemma local, embeddings in-VPC, Tiger in your Postgres. Raw SOW never leaves your boundary. Embeddings-only + auto-delete kills the you store contracts objection.
Zero marginal cost = 19/mo viable: local Gemma + cached TabPFN/SerpApi, tokens 0. Telemetry token_savings_vs_gpt4o_pct 35.0.
Fine-tune beats prompting: Tinker LoRA teaches strict JSON and exclusion enforcement (5.2/7.1 traps), swappable gemma-2-9b to gemma-3-4b via env.
Separation a closed LLM cannot do: TabPFN owns numbers, Tiger owns retrieval, Gemma owns words. Composable open pieces, not one black box.

If a closed model reprices or drifts, ScopeShield still audits. That is the moat.

My Agent Session

Build trace: Thu Tiger+TabPFN, Fri Gemma+Tinker+SerpApi, Sat demo polish + DEV draft. Entire/Copilot export in appendix.

Session embed pending — will add the DevRelay session link here once saved.

Prize Categories

Best Use of TabPFN (200): engine_tabpfn.py 9-feature fit-120 predict_proba inside agent
Best Use of Tinker (200): 250+50 pairs + benchmark validity/F1/tokens
Best Use of Gemma (200): gemma-2-9b-it Ollama strict-JSON repair retry
Best Use of Tiger Data (100): pgvector+tsvector RRF SQL
Best Use of SerpApi (100): live rate grounding 24h cache cited in order
Best Use of Sentry Agent Tracing (100): full-audit transaction + 4 spans
Best Use of Entire (100): sessions in appendix
Best Use of GitHub Copilot (100): agent/CLI build

By @aryan1092raj — solo build, MIT open source.

WalkTalk: Turn Screen Meetings into a Walk 🎧

Aryan Raj — Sun, 11 Oct 2026 06:21:22 +0000

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

What I Built

WalkTalk — Turn Screen Meetings into a Walk 🎧

WalkTalk lets you turn meeting agendas into audio and take discussions outdoors. Record the conversation on your phone, then process it on your laptop to generate transcripts, identify speakers, and create meeting minutes linked to audio evidence.

Built for students and teams who want to spend less time at their screens without losing important meeting details.

Demo

GitHub Repository

Code

Built with Python using Piper TTS, DeepFilterNet3, faster-whisper, pyannote.audio, and Ollama.

How I Built It

WalkTalk combines open-source audio tools with local LLM inference using Qwen2.5 7B Instruct. Its pipeline handles agenda narration, denoising, transcription, speaker diarization, and meeting minutes. Models run sequentially to fit systems with around 6 GB VRAM.

Why Does Open Innovation Matter?

Open-source AI makes this workflow possible without depending on paid cloud AI APIs. After setup, processing runs locally, keeping meeting recordings on the user's machine and allowing offline use.

My Agent Session

View WalkTalk on GitHub

Prize Categories

Best Use of Gemma — Gemma 3 4B is supported as a fallback model.

devchallenge #hf26challenge

Exam_tutor

Aryan Raj — Sun, 04 Oct 2026 15:09:25 +0000

What I Built

A local exam-prep tutor for my friend Nishant. He [his real problem, e.g. "studies from scattered notes and web pages and has no way to test himself"] before [course/exam]. Paste URLs or upload PDFs, then either ask questions (answered only from his notes, with sources shown) or get quizzed and graded on his own answers.

Demo

[video link]

Code

Aryan1092raj / Exam_tutor

Exam Tutor

Local RAG study partner built for my friend Nishant. Paste URLs or upload notes, then ask questions or get quizzed. Everything runs on-device with open-weight models via Ollama. No API key, no internet needed after setup, notes never leave the laptop.

Setup

# 1. install Ollama: https://ollama.com
ollama pull qwen2.5:3b
ollama pull nomic-embed-text

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

Use

Sidebar: paste URLs (web pages or PDFs) or upload files, click Ingest.
Ask mode: question gets answered only from the ingested notes, with sources shown.
Quiz me mode: enter a topic, get an exam-style question, answer it, get graded.

Sample sources to try (data structures):

https://en.wikipedia.org/wiki/Binary_search_tree
https://en.wikipedia.org/wiki/AVL_tree
https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm

How it works

Chunk text (900 chars, 150 overlap)
Embed chunks with nomic-embed-text (Ollama)
Cosine similarity over numpy matrix, top 4 chunks
qwen2.5:3b answers using only retrieved chunks
Swap model: edit CHAT_MODEL in app.py

Stack

…

View on GitHub

How I Built It

Chat model: Qwen2.5 3B via Ollama, runs on a laptop CPU/GPU.
Embeddings: nomic-embed-text via Ollama.
Retrieval: notes chunked (900 chars, 150 overlap), embedded, cosine similarity over a numpy matrix, top 4 chunks fed to the model.
Grounding: system prompt restricts answers to retrieved notes; if notes don't cover it, it says so.
Quiz mode: model writes one exam-style question from retrieved chunks, then grades the student's answer against them.
UI: Streamlit. Ingestion via trafilatura (web) and pypdf (PDFs).
Whole thing is ~150 lines, one file.

Why Does Open Innovation Matter?

Offline: works with bad hostel wifi. After model pull, zero internet needed.
Private: his notes never leave his laptop.
Free: no API key, no per-query cost, no rate limit during exam week.
Swappable: changing the model is one line (CHAT_MODEL). [Add your real 3B vs 7B comparison, or delete this sentence.]
A closed API would need billing, a key, and a connection, which is exactly what a student doesn't want the night before an exam.