DEV Community: Lakshay Deol

Hammock: The Gentle AI "Sloth" That Triages Your GitHub Issues Overnight (And Never Speaks Without Permission) 🦥💤

Lakshay Deol — Fri, 23 Oct 2026 16:28:57 +0000

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

What I Built

Every maintainer knows the morning dread. Forty notifications, and before writing a line of code you answer the same four questions in the same order: Is this a duplicate? Is it even a bug? Which version are you on? Can you give me a minimal reproduction?
Hammock is an overnight triage sloth. A durable Temporal workflow fetches new and updated issues idempotently, classifies them with a local Gemma 4 model, recalls duplicate reports with embeddings, asks Gemma to adjudicate whether two issues share the same technical root cause, and drafts the reply that asks for exactly what's missing. Then it stops.
It applies allowlisted, reversible labels on its own. Everything public : comments, closes, locks, assignments waits in a local queue for one maintainer tap.
Hammock can propose anything. It can only do the reversible things alone.

Labels on an allowlist: automatic.
Comments, closes, locks, and assignments: your tap.

Action	Who decides
`bug`, `needs-info`, `feature`, `duplicate`, `question`	Automatic — additive, allowlisted in `.hammock.yml`
Comments, closes, locks, assignments	Your tap — always, with no config that disables it

The person who gets to be a little lazier is a maintainer at 7am: instead of forty tabs, they get a short queue of drafts to approve, edit, or discard.
The person who gets to be a little lazier is a maintainer at 7am: instead of forty tabs, they get a short queue of drafts to approve, edit, or discard.

Demo

video

live demo

hammock-maintainer-dashboard.onrender.com

To run on Local Device
60-second reviewer path — no Ollama, no Temporal, no tokens:

git clone https://github.com/Lakshay-Deol/Hammock.git
cd Hammock
pnpm install && pnpm build

pnpm hammock eval-dedupe --replay     # precision / recall vs ground truth
pnpm hammock test-fixtures --replay   # 8 fixtures incl. 3 prompt injections
pnpm hammock dashboard                # http://localhost:3000

Code

Lakshay-Deol / Hammock

🦥 Hammock

Hammock triages your GitHub issues overnight on a local Gemma 4 model. It labels, spots duplicates and drafts replies — and touches nothing public without your tap.

Reversible alone. Visible never.

Submission for the Hacktoberfest Open-Source AI Challenge (Week 3: Slow and Steady).

🎯 The Core Thesis

Hammock can propose anything. It can only do the reversible things alone.

Labels on an allowlist: automatic Comments, closes, locks, and assignments: your tap.

Most AI triage bots call hosted models on public webhooks and post directly to repositories without supervision. Hammock runs 100% locally, overnight, durably via Temporal, and strictly refuses to speak in public without maintainer approval — proving every action with an immutable receipt.

🏗️ Architecture

GitHub REST API
      │  since + ETag (conditional, idempotent)
      ▼
Temporal schedule "nightly-triage"
      │
      ▼
workflow: fetch → per-issue activity fan-out → digest
      │
      ├─► Mastra agent ──►

…

View on GitHub

How I Built It

Gemma 4 via Ollama does three genuinely different jobs, each shaped by a different failure mode:

Classification returns Zod-validated JSON : type, severity, confidence, missing_info[], suggested_labels[], summary. The thinking channel (<|channel>thought … <channel|>) is stripped before parsing, so a rambling model can't corrupt the object. A verdict that fails validation is an error, not a guess.
Duplicate adjudication is hybrid by necessity. nomic-embed-text embeddings plus cosine similarity over SQLite recall the top-3 candidates; Gemma then answers the narrower question : do these share the same technical root cause? and must return an evidence string. In the benchmark, a true duplicate sat at 0.979 similarity while a false friend sat at 0.919 and was correctly ruled distinct. The embedding finds candidates; the model decides.
Drafting produces a tone conditioned reply listing exactly the missing information, derived from the verdict rather than the raw issue body.

Temporal carries the overnight pass: a deterministic workflow with per-issue activity fan out, defined timeouts, and a registered cron schedule, so a laptop asleep at 2am resumes instead of double labelling.

Mastra defines the triage agent and its four typed tools (classifyIssue, embedIssue, findDuplicates, draftReply) over the local Ollama model a provider-agnostic contract for the loop, while the deterministic activities call the same primitives directly so workflow replay stays pure.

SQLite (better-sqlite3) stores issues, verdicts, proposals, embeddings, and append-only receipts in WAL mode. Hono serves the cockpit: an editable draft per pending proposal, a live character-count diff indicator, approve/reject, and the receipt log.

Two design decisions I'd defend:

Issue text is fenced in <untrusted_issue_data> and the model's only job is to emit JSON, which is validated before anything reads it. Adversarial fixtures come back injection_suspected: true and produce nothing no label, no queued draft so there's nothing for a tired maintainer to approve by accident.
Rejection calls no GitHub API at all. That's the point: rejecting leaves provably zero trace on the repository, while still recording who, when, why, and the text that was never sent.

There is also a replay adapter a real ModelClient implementation that swaps the transport and reads recorded verdicts through the same Zod schema. Every code path after the model call is the production path. It exists so a judge with no GPU, no Ollama, and no tokens can still run the whole thing in one minute.

Why Does Open Innovation Matter?

Because the alternative is shipping your bug reports to someone else's API.

Private issue trackers contain internal hostnames, database schemas, customer identifiers, and proprietary stack traces. Running Gemma locally via Ollama makes "triage 500 issues overnight" cost $0.00 in tokens and zero bytes of exfiltration. It also means the tool works on a plane, in an air-gapped environment, and after the maintainer stops paying someone's subscription.

Open weights made the trust model possible, not just the economics. Because I can run the model locally, and read the SDKs it is wrapped in, I can make a real promise about what never leaves the machine — and I can show the receipt for every decision, including the ones that never touched GitHub. A closed API could give me a better classifier; it could not give me that guarantee. And because everything is open, the interesting part — the approval gate, the sandbox assertion, the reversibility split — is auditable by anyone who disagrees with me.

The Lazy Payoff

Measured on the fixtures in the repo, all reproducible offline:

Metric	Result
Deduplication precision	100.0% (TP 3, FP 0)
Deduplication recall	100.0% (TN 5, FN 0)
F1	1.000
Avg cosine similarity — true duplicates	0.971
Avg cosine similarity — distinct pairs	0.236
Prompt injections neutralized	3 / 3
Fixture acceptance	8 / 8
Test suite	26 / 26 across 7 files

On a sandbox pass of 8 issues: 6 allowlisted labels applied automatically, 5 drafts queued, 1 duplicate flagged — one tap per public action instead of writing each reply from scratch.

Two footnotes, because benchmarks without them are marketing:

The dedupe set is 8 hand-labelled pairs, not a scraped corpus. It demonstrates the adjudication logic — a 0.919 similarity correctly ruled distinct — not statistical significance.
Replay is not a speed benchmark. The replay adapter reports a fixed placeholder throughput; real tok/s depends on your hardware. Measure it with pnpm hammock verdict fixtures/issue-001.json and confirm the client name does not say [replay]

Prize Categories

Best Use of Gemma — Gemma 4 (gemma4:e4b) does three distinct jobs locally: schema-validated classification, root-cause duplicate adjudication with an evidence string, and tone-conditioned reply drafting. Issue text never leaves the machine, and the pipeline survives a full network disconnect.

Best Use of Temporal — the nightly pass is a deterministic workflow with per-issue activity fan-out, defined timeouts, and a registered cron schedule, so interruptions resume rather than duplicate work.

Best Use of Mastra — the triage agent and its four typed tools are defined in @mastra/core, giving the loop a typed, provider-agnostic contract over the local model.

Best Use of Auth0 for AI Agents — approval is modelled as asynchronous authorization: a pending proposal carries an authorization request, and the write path is gated on an approval identity recorded on the receipt. The adapter is swappable; the demo runs its local-session fallback.

Kintsugi : A Side Hustle Repair Assistant for Technicians Who Can't Afford a Wrong Answer

Lakshay Deol — Sun, 18 Oct 2026 09:49:38 +0000

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

What I Built

Kintsugi (金継ぎ) is a manual-grounded AI appliance repair assistant for technicians, repair shops, and repair-café volunteers. A technician enters a brand and model number, describes the symptom, and Kintsugi answers using only that model’s service manual. Every technical claim carries a [Page X] citation. If the manual is missing, if retrieval scores fall below a calibrated threshold, or if the procedure involves mains voltage, natural gas, or sealed refrigerants, Kintsugi refuses deterministically before calling the LLM.

The problem it solves is not “technicians lack information.” It is that a generic chatbot is confidently wrong about safety-critical procedures. A fabricated torque spec strips threading. A guessed electrical test creates a shock or fire hazard. A made-up error-code meaning sends the technician to replace a $180 control board that was never faulty.

Who pays: Independent appliance technicians and small repair shops. A single avoided misdiagnosis pays for a month of access. Repair-café volunteers are a secondary, non-paying group who get the offline Ollama path.

Demo

Video

Demo site

kintsugi-hx3b.onrender.com

Code

Repo: https://github.com/Lakshay-Deol/kintsugi
Reproduce locally

git clone https://github.com/Lakshay-Deol/kintsugi.git
cd kintsugi
pip install -e .
cp .env.example .env   # insert MONGODB_URI and LLM_API_KEY
python scripts/gate_phase0.py
python scripts/gate_phase1.py
python scripts/gate_phase2.py
python scripts/gate_phase3.py
python scripts/gate_phase4.py
python -m uvicorn kintsugi.api.app:app --host 127.0.0.1 --port 8080

How I Built It

Kintsugi is built around three deterministic gates and a hybrid retrieval layer, with open-source and open-weight models doing the synthesis.

The three gates (all before or after the LLM, never inside it):
Query (model + symptom)

→ Gate 1: Hazard filter → REFUSE: HAZARD_REFERRAL (no DB/LLM) →
MongoDB Atlas hybrid retrieval

→ Gate 2: Retrieval gate → REFUSE: LOW_RELEVANCE / MODEL_NOT_FOUND
→ Gemma synthesis

→ Gate 3: Citation verifier → strip ungrounded pages
→ Verified answer with [Page X]

Gate 1 and Gate 2 run before the LLM call. Refusals cost zero tokens.

MongoDB Atlas — Hybrid search.vector_indexstores 384-dimensional dense vectors on kintsugi.chunks with pre-filters on brand and model, so a Bosch query cannot retrieve a Whirlpool chunk. bm25_index is an Atlas Search full-text index tuned for alphanumeric error codes (F5E2, E18) and component IDs that dense embeddings handle poorly.

The two ranked lists are fused in the application layer with

Reciprocal
Rank Fusion : score = 1/(60 + rank_vector) + 1/(60 + rank_bm25).

Google Gemma — bounded synthesis. The primary reasoning engine is a Gemma model served via Google AI Studio through the google-genai SDK. Prompts are bounded to retrieved excerpts and require structured output with [Page X] citations. An offline open-weights path (gemma3:12b via Ollama) is benchmarked for rural repair cafés and air-gapped workshops.

Embeddings. 384-dimensional embeddings are precomputed offline at ingestion time. The query embedder is a lightweight ONNX path. A warm transformer is not loaded in the Render web service — the free tier cannot afford it.

Render. Declarative render.yaml, /health endpoint that checks database connectivity and demo-mode status, and proxy-aware rate limiting (proxy_headers=True, forwarded_allow_ips="*") so limits apply per client IP behind Render’s edge proxy.

Why Does Open Innovation Matter?

Because the alternative is a closed chatbot that guesses, and a technician has no way to see that a claim was never grounded.

Open models and open infrastructure made two things possible that a closed API would not:

An offline path. The Ollama gemma3:12b route lets a repair café in a basement with no internet run the same grounding and refusal logic. A closed API cannot be shipped to an air-gapped workshop.

A refusal path that costs nothing and can be inspected. Because the gates are local code, not a vendor policy, anyone can read them, calibrate the thresholds, and audit the citation verifier. The safety behavior is open source, not a black box.

Measured cost, per query:

Customer Story

A technician traced an intermittent fault on an OEM diagnostic reader. The fix itself was small; the problem was that the reader needed the vendor's server to confirm it. No internet in the bay, no confirmation, no repair that day.

He said the thing that stuck: if a tool could do that daily, offline, he'd pay for it not a flat fee, but a share of what it earned him. Two percent of profits, because a flat subscription is a cost whether or not the work comes in, and a percentage only costs him when the tool actually pays.

That is the constraint Kintsugi is built around. Not "works when the network works" works in a basement repair café with no signal, on a laptop with gemma3:12b running locally. The refusal gates and the citation check run in the same offline path as the cloud path. A tool that only works online fails exactly when a technician is standing in front of an open appliance.

Prize Categories

Gemma: Gemma is the synthesis engine behind every grounded answer, and the Ollama gemma3:12b path makes Kintsugi usable offline in repair cafés.

MongoDB Atlas: Atlas Vector Search and Atlas Search are fused with RRF, so semantic retrieval and error-code keyword matching reinforce each other.

Render: Kintsugi ships as a declarative render.yaml Blueprint with a /health endpoint and proxy-aware rate limiting on Render’s free tier.