This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
Modern devices bombard us with over 120 notifications every day. Every ping fractures our focus, spikes cortisol, and creates constant cognitive fatigue. Yet we cannot simply turn on "Do Not Disturb" because of the lingering anxiety: What if the hospital calls? What if my card is charged fraudulently? What if my family is stranded?
Hush is a 100% local, on-device attention operating system. It ingests every incoming notification (macOS notification center, WhatsApp, Slack, Teams, SMS) and background IMAP emails, evaluates them against an inspectable deterministic attention cost model using a local open-weight Gemma 2B model, and presents exactly four lines every three hours.
Hush breaks your silence only when an incoming event clears a strict emergency threshold ($T_{\text{high}} \ge 0.55$) — such as a hospital admission, banking fraud alert, or family roadside breakdown. Everything else is quietly queued into your 3-hour brief or silently discarded with a transparent audit log.
Who gets to be lazy?
Knowledge workers, software engineers, writers, and deep-work practitioners. You get to be productively "lazy" by never checking your notification shade again, knowing an unblinking local guardian will wake you up if and only if your real world is on fire.
Note on Live Web Demos: The interactive web dashboard runs in demo sandbox mode on Vercel/GitHub Pages with zero installation required, while your live production instance runs strictly on-device on your local machine (http://localhost:8484 / mobile LAN) to guarantee 100% data privacy.
A local attention router that reads every notification so you only have to read four.
🌐 Live Web App (Vercel): https://hush-ai-os.vercel.app
🌐 Mirror (GitHub Pages): https://aiwithrajan.github.io/hush/
🎥 Demo Video (1080p): hush_demo_1080p.mp4
Built for the Hacktoberfest Open-Source AI Challenge, Week 3 — "Slow and Steady".
Hush is an on-device attention router. It reads every notification your Mac receives, ranks them against an inspectable deterministic cost model, and presents exactly four lines every three hours. It interrupts you only when an incoming message clears a threshold high enough to justify breaking your silence ($T_{\text{high}} = 0.55$).
Everything runs locally on-device using an open-weight Gemma model via Ollama. No notification bodies, titles, or message contents ever leave the machine.
Hush is defined by an empirical test, not a feature list:
10 staged emergencies spanning health, banking fraud, family…
Hush is built with a rock-solid, zero-trust architecture designed around two foundational pillars:
[ macOS Notification DB ] ──┐
├──> [ Ingestion Engine ] ──> [ SQLite WAL DB ]
[ Direct IMAP Email SSL ] ──┘ │
▼
[ Gemma 2B (Local Ollama) ] <────── Prompts ───────────── [ Classifier ]
│
▼ (urgency, category, deadline)
[ Deterministic Cost Scorer ]
│
├─► [ Emergency (Score ≥ 0.55) ] ──> [ Temporal Never-Nag-Twice Escalation ]
├─► [ 3-Hour Brief (0.15 - 0.54) ] ──> [ Quota Router: 4 Lines / 3 Hours ]
└─► [ Discard Pile (< 0.15) ] ─────> [ Transparent Audit Log ]
We run Google's Gemma 2B quantized model on local CPU/Metal inference via Ollama. No cloud APIs. Zero monthly tokens. Zero external latency.
Gemma extracts three atomic variables from every notification without seeing private user IDs:
health, money, person, deadline, work, promo)
Large Language Models are probabilistic and can hallucinate. You cannot trust an LLM to directly decide whether your phone rings at 2:00 AM.
Hush enforces a strict Determinism Boundary:
health: 1.00, money: 0.90, promo: 0.05), and deadline decay exponentially increases weight as real-world cutoffs approach.
Hush relies on Temporal durable execution for capabilities impossible with basic Python scripts:
asyncio.sleep drifts or dies. Temporal's durable timers preserve state in persistent storage. When your laptop wakes up, execution resumes without skipped cadences.activity_classify_pending, ensuring zero notification drops.
Before trusting Hush, we built an empirical Notification Fire Drill into the core engine. We staged 10 real-world emergencies (ER hospitalization, Chase fraud, stranded sister, production database failover) and 5 hard negative controls ("50% Off Flash Sale", funny WhatsApp memes with "EMERGENCY 😂", routine Jira tickets).
The local Gemma + Temporal engine scored:
Open innovation is not just an ideological choice for Hush; it is the only architecture that makes this product legally, ethically, and technically viable.
This project was built through autonomous agent pair-programming:
FLPM6kshMRqqZ2uqq6FN1byt
During testing this week, Hush turned 147 raw pings and emails into just three 4-line briefs:
Quantified time saved:
The average recovery time after a context switch is 23 minutes. By reducing daily interruptions from 25+ to zero non-emergency interruptions, Hush saves an estimated 1.5 to 2 hours of fractured attention every single day. You get to be lazy about managing pings, so your brain can stay in effortless flow.