DEV Community: Harshit Agarwal

Ghostwriter AI: What if the AI Storyteller Remembers Every Mistake You Make?

Harshit Agarwal — Wed, 28 Oct 2026 07:04:10 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Ghostwriter AI — Every Choice Leaves a Scar is an interactive, unscripted gothic horror storytelling generator designed to give players genuine narrative agency while confronting them with the indelible consequences of their decisions.

Traditional text adventures rely on static, pre-written decision branches: choose option A or B to jump to passage 12 or 13. Conversely, modern conversational AI chatbots often suffer from narrative amnesia, abrupt tonal drift, or cheerful assistant personas that completely dissolve suspense.

The Interpretation of "Ghost in the Machine"

In gothic folklore, a haunting is an unresolved echo of past trauma trapped inside an environment. In Ghostwriter AI, the "Ghost" is the persistent memory ledger trapped within the machine.

The machine does not just generate words—it holds a grudge. As you explore eerie domains (from the decaying halls of Blackwood Manor to abandoned sanitariums and cursed hamlets), the engine continuously tracks your discovered clues, psychological wounds, unprompted actions, and fateful decisions. Every choice leaves an irreversible scar on the narrative ledger, culminating in a climactic autopsy ending (Escape, Survival with a cost, Tragic ending, Supernatural revelation, or Hidden ending).

Demo

GitHub Repository: https://github.com/Harshitagarwal113/GhostWriter-AI

Visual Preview & Experience

The application features a dark gothic aesthetic inspired by classic horror literature:

Atmospheric Palette: Near-black charcoal backgrounds (#0a0a0c), dynamic vignette, subtle SVG noise film grain, and restrained blood-red accents.
Cinematic Typography: Cinzel for regal titles and headers, EB Garamond with dedicated dialogue styling for story passages, and Inter for accessible UI controls.
Interactive Consequence Ledger: The collapsible "What the darkness remembers" panel dynamically displays clues, inventory relics, character states, and permanent scars.
Unscripted Agency: Players can choose from three dynamically generated choices (with keyboard shortcuts [1], [2], [3]) or type freeform custom actions (e.g., "Press your fingertips against the peeling wallpaper near the hearth to feel for drafts").

Code

Harshitagarwal113 / GhostWriter-AI

Ghostwriter AI — Every Choice Leaves a Scar

An unscripted interactive horror-story generator where the machine remembers your decisions, powered by Google's open-weight Gemma model via the Gemini API.
Built for the DEV.to Hacktoberfest Week 4 2026 Challenge: "Ghost in the Machine".

📖 The Problem and Creative Concept

Traditional text adventures and branching narrative games rely on pre-written decision trees. If you choose Door A, you get pre-baked Paragraph 12; if you choose Door B, you get pre-baked Paragraph 13. While predictable, this approach limits player agency and quickly loses tension once branches are discovered.

On the other hand, unstructured conversational AI chatbots lack memory discipline: they frequently suffer from tone drift, forget past decisions within a few turns, and lack pacing or stakes.

Ghostwriter AI bridges this gap It acts as an intelligent, literary storyteller that weaves genuine gothic horror. Every choice you select—or custom unscripted action you…

View on GitHub

Direct Repository Link: https://github.com/Harshitagarwal113/GhostWriter-AI

How I Built It

Ghostwriter AI is built as a decoupled, high-performance full-stack web application designed for deterministic state management and zero-leak AI inference.

GhostWriter AI/
├── frontend/                 # React 19 + TypeScript + Tailwind CSS + Vite
│   ├── src/
│   │   ├── components/       # AtmosphericBackground, StoryChoices, DarknessLedger, etc.
│   │   ├── pages/            # LandingPage, StorySetupPage, StoryPlayerPage, EndingPage
│   │   ├── hooks/            # useStorySession, useApiHealth
│   │   ├── services/api.ts   # Centralized Fetch API client with timeouts & retry logic
│   │   └── types/story.ts    # Type-safe TypeScript contracts
├── backend/                  # Python 3.14 + FastAPI + Pydantic v2 + google-genai
│   ├── app/
│   │   ├── api/routes.py     # /api/health, /api/story/start, /api/story/advance
│   │   ├── services/         # gemma_client.py, story_engine.py, story_memory.py
│   │   ├── prompts/          # storyteller.py (gothic system instructions & templates)
│   │   └── main.py           # FastAPI server with CORS & error handlers
│   └── tests/                # 13 automated Pytest unit and integration tests
└── README.md

The AI Engine: Google's Open-Weight Gemma Model

Model: Google's open-weight Gemma model (gemma-4-26b-a4b-it default, gemma-4-31b-it high-reasoning alternative).
Integration: Implemented through Google's official Gen AI Python SDK (google-genai) and the Gemini API delivery endpoint.
Bounded Retry & JSON Sanitation: Language models can occasionally emit markdown code fences or non-JSON preamble. Our gemma_client.py strips fences, isolates JSON object boundaries, and executes a bounded single-retry fallback to guarantee valid structured schemas without redundant token consumption.
Pacing Engine: To prevent open-ended AI rambling, story length budgets (Short: 3–4 scenes, Medium: 5–7 scenes, Long: 8–10 scenes) guide Gemma from escalating tension directly into a fateful climax.
Automated Test Suite: 13 automated unit tests cover health reporting, Pydantic input validation, mocked story progression, custom action resolution, and CORS preflight.

Why Does Open Innovation Matter?

Open innovation and open-weight models like Gemma are transformative for interactive fiction and creative AI development:

Transparency & Auditable Alignment: Unlike proprietary black-box APIs whose system prompts, tokenizers, and alignment penalties can change without notice, open-weight models give developers full insight into model behavior, allowing creators to craft precise narrative systems with confidence.
Creative Literary Expression Without Sanitization: Horror fiction relies on psychological tension, dread, and eerie themes. Closed commercial models often over-censor atmospheric horror prompts into bland cheerful statements. Open models respect literary nuance while keeping safety boundaries intact.
Reproducibility & Longevity: An interactive story built on open standards won't break if a vendor deprecates a proprietary endpoint. Developers can run open weights locally, fine-tune them on gothic literature corpora, or deploy them through hosted APIs.

My Agent Session

This application was developed, tested, and integrated with the assistance of agentic pair-programming workflows:

Conversation ID: acff272d-74b8-48dc-9bf7-171b332d47c4
Tooling: DevRelay Gateway, Google Gen AI Python SDK, Browser Subagent Verification

The Spirit of It

During our live test of the Haunted Mansion scenario, the protagonist Eleanor encountered a weeping portrait over an ancient hearth. Instead of taking a pre-generated choice, we tested the custom action input:

Player Action: "Press your fingertips against the peeling wallpaper near the hearth to feel for drafts."

Gemma didn't give a canned response. It adapted to her exact touch:

"Eleanor's fingers brush against the desiccated, floral patterns of the wallpaper... beneath the layer of decay, her touch finds the unmistakable, sharp edge of a recessed latch, cold as a tombstone. A hollow, rhythmic tremor shudders through the wall—vibrating like a biological pulse."

When she manipulated the latch in the final scene, the climax landed with true chills:

"There is a wet, sickening sound—the sound of a suture tearing through muscle. The wall does not swing on hinges; it peels back like a heavy, weeping eyelid... Eleanor discovers that Blackwood Manor is not a house, but a predatory, sentient organism."

The memory ledger immediately updated her status to "Sensory assimilation" and "Fatal entrapment", sealing her fate in "The Eternal Pulse" ending. That was the moment the project truly came alive: the machine wasn't just predicting the next token—it was remembering her curiosity and turning it into her undoing.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 4: "Ghost in the Machine"

Project Janitor: The 100% Offline AI File Organizer with Zero Cloud Egress & Instant Undo

Harshit Agarwal — Fri, 23 Oct 2026 18:10:52 +0000

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

What I Built

Project Janitor is an intelligent, privacy-first desktop file organizer and duplicate file manager for Windows. It solves a universal digital headache: the chaotic accumulation of redundant downloads, scattered project archives, unorganized documents, and duplicated media across personal workspaces.

Instead of spending hours manually sorting through nested folders, comparing modification timestamps, or risking accidental deletion of important files, Project Janitor automates the entire cleanup lifecycle with deterministic safety:

High-Speed Filesystem Scanner: Indexes target folders in milliseconds using read-only os.scandir and maps files into 7 structured categories (documents, images, videos, audio, archives, code, other).
Cryptographic Duplicate Detection: Groups files by exact byte size and computes chunked SHA-256 hashes to guarantee bit-for-bit identity. Identifies one canonical copy to retain and flags redundant copies without ever deleting files automatically.
Local Google Gemma AI Classification: Leverages open-weight Google Gemma 2B running on-device via Ollama to analyze text files, infer context, suggest descriptive filenames, and categorize ambiguous items—all with 100% offline privacy.
Dry-Run Cleanup Planner: Proposes clean directory layouts (By Category, By Date, or Flat Root) and automatically resolves naming collisions with numeric suffixes (_1, _2). Files are never modified during planning.
Explicit Approval & Transactional Undo: Every approved file move is logged into an ACID-compliant local SQLite journal (data/janitor_journal.db), enabling instant, one-click reversible rollback for single operations or full plans.

Who Gets to Be a Little Lazier?

Developers, designers, researchers, and everyday Windows power users who dread the manual chore of organizing their Downloads, Desktop, or sprawling project directories. You can clean up hundreds of disorganized files in under 30 seconds with complete peace of mind, knowing that every action is previewed, confirmed, and completely reversible.

Demo

Project Janitor features a clean, minimalist desktop application interface built with React 19, Tailwind CSS v4, and Lucide icons:

1. System Overview Dashboard

Live monitoring of indexed storage volume, category distribution bar charts, recorded journal operations, and local Ollama / Gemma AI availability—with zero invented statistics.

2. Multi-Stage Workflow

Folder Scanner: Scans user-authorized directories while strictly protecting drive roots (C:\, D:\) from accidental selection.
Scan Results: Paginated explorer with live search and category filters.
Duplicate Review: Displays verified SHA-256 match groups, retained copies, and potential reclaimable storage.
Cleanup Plan Review: Highlights dry-run recommendations (PROPOSED DRY-RUN badge), proposed destinations, rationale, and confidence scores.
Approval Modal: Demands explicit checkbox confirmation with an interactive preview of every operation awaiting execution.
History & Rollback: Complete transactional audit trail with verified one-click rollback.

Code

The complete source code is open-source under the permissive MIT License:

Harshitagarwal113 / Project-Janitor

A 100% offline, privacy-first desktop file organizer and SHA-256 duplicate manager with local Gemma AI and reversible SQLite undo.

🧹 Project Janitor

Deterministic, Privacy-First Desktop Storage Organizer & Duplicate Manager with Local AI for Windows.

Overview

Project Janitor is an offline system utility for Windows that analyzes messy directories, detects exact byte-for-byte duplicates using cryptographic SHA-256 hashes, generates dry-run cleanup plans with optional local Google Gemma 2B AI, and executes file moves with an explicit review step and reversible SQLite rollback.

100% Local: No cloud subscriptions, no telemetry, and zero paid API keys.
Non-Destructive: Never deletes files automatically. Duplicates are flagged for manual review.
Transactional Rollback: Every move/rename is recorded in a local SQLite journal (data/janitor_journal.db).
Offline AI Fallback: Runs with local Gemma 2B via Ollama. Falls back to deterministic rules if offline.

Core Capabilities

Capability	Method	Key Benefit
Recursive Scanner	Non-blocking, read-only `os.scandir` with path containment	Categorizes into 7 types; blocks drive roots (`C:\`, `D:\`)
Exact Duplicate Engine	Size

…

View on GitHub

Repository: https://github.com/Harshitagarwal113/Project-Janitor

Architecture Highlights:

Frontend (frontend/): React 19, TypeScript (strict typechecking), Vite 6, Tailwind CSS v4, Lucide React, Vitest.
Backend (backend/): FastAPI, Pydantic v2, Python 3.12+, Uvicorn, pytest, pytest-asyncio.
Database (data/): Isolated SQLite transaction journal (janitor_journal.db).
AI Service (backend/app/services/ollama.py): Local Ollama HTTP REST client with prompt injection isolation.

How I Built It

Project Janitor was architected from the ground up around open-source AI and local edge inference:

graph LR
    User["User Target Folder"] --> Scanner["Read-Only Scanner"]
    Scanner --> Duplicates["SHA-256 Engine"]
    Duplicates --> Planner["Dry-Run Planner"]
    Planner <--> Gemma["Local Google Gemma 2B (Ollama)"]
    Planner --> Approval["Explicit Approval Dialog"]
    Approval --> Executor["Atomic Shutil Execution"]
    Executor <--> Journal[("SQLite Transaction Journal")]

1. Open-Source AI: Google Gemma 2B

We utilized Google Gemma 2B (gemma:2b), an open-weight model developed by Google DeepMind.
Gemma 2B was chosen specifically for its balance of strong language understanding, lightweight footprint, and fast token generation.

2. Local Inference via Ollama

Rather than relying on cloud endpoints, Project Janitor communicates directly with a locally running Ollama daemon at http://127.0.0.1:11434.
4 GB VRAM Optimization: When quantized to Q4_K_M, Gemma 2B uses ~1.7 GB to 2.2 GB VRAM. This fits comfortably within the 4 GB VRAM ceiling of entry-level developer laptops (such as the NVIDIA GeForce RTX 3050 Laptop GPU), leaving ample memory for the Windows Desktop Window Manager and system displays without CUDA out-of-memory errors.

3. Untrusted Prompt Sandboxing & Security

To prevent prompt injection attacks from malicious files on disk, text file samples (maximum 1,500 characters) are encapsulated inside strict XML isolation boundaries:

  <untrusted_file_content>
  ... inert file content ...
  </untrusted_file_content>

Binary files (.exe, .png, .pdf, .zip) are classified strictly from metadata without reading raw bytes.

4. Structured JSON Output & Deterministic Fallback

Ollama is invoked with format: "json" and temperature: 0.0.
All model responses are validated through strict Pydantic schemas (AIClassificationResponse). Any malformed output, out-of-bounds confidence scores, or service timeouts immediately fall back to deterministic rule heuristics with zero loss of system safety.

Why Does Open Innovation Matter?

Open innovation is not just an alternative for Project Janitor—it is the only viable architecture:

Absolute Storage Privacy: Filesystems hold user tax filings, medical records, proprietary source code, private keys, and personal photos. Sending file paths, filenames, or content excerpts to closed-source cloud APIs (OpenAI, Anthropic) violates fundamental privacy expectations. Open innovation keeps data strictly inside the user's machine.
Zero Cost & Infinite Shelf Life: Closed AI APIs impose monthly subscriptions, credit card requirements, token fees, and rate limits. With open-weight models like Gemma running on open-source runtimes like Ollama, Project Janitor is 100% free forever, operates completely offline in airplane mode, and never suffers vendor deprecation.
Auditable Code & Reproducible Safety: Filesystem operations require absolute trust. Open-source innovation allows anyone to inspect our path validation, cryptographic hashing, and transaction rollback engines to verify that files are never secretly sent elsewhere or deleted without permission.

My Agent Session

Project Janitor was developed using the Google DeepMind Antigravity IDE pair-programming agent workflow. Across 10 structured engineering phases:

The agent designed and verified the decoupled architecture, ensuring strict boundaries between the React SPA and the FastAPI engine.
Implemented comprehensive automated test suites: 57 backend pytest tests (covering path sandboxing, duplicate hashing, AI schema validation, and rollback) and 20 frontend Vitest tests.
Conducted real end-to-end browser subagent testing on Windows to verify the complete user journey: scanning $\rightarrow$ duplicate review $\rightarrow$ dry-run planning $\rightarrow$ approval modal $\rightarrow$ execution $\rightarrow$ transactional undo.
Synthesized community best practices around non-destructive filesystem design patterns and explicit imperative confirmation modals.

The Lazy Payoff

The Numbers:

Manual Sorting Time: ~45 minutes to sort 250 messy downloads, verify duplicates, create folders, and move files.
Project Janitor Time: 15 seconds to scan, detect duplicates, generate a dry-run plan, and execute.
Time Saved: ~99% reduction in manual effort.

The Real Payoff: "Anxiety-Free" Laziness

The hardest part of organizing files isn't dragging and dropping—it's the mental anxiety of "What if I accidentally delete an important file or break a project path?"

Project Janitor's Dry-Run Preview, Explicit Approval Checkbox, and One-Click Transactional SQLite Rollback remove all anxiety. You can be lazy and let the organizer tidy up your entire directory knowing that every single file move can be instantly undone with one click.

Prize Categories

🏆 Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

Category: Built with open-weight models (Google Gemma 2B) and open-source local inference (Ollama) on Windows.
Track: Offline Edge AI, Developer Productivity & Open-Source System Utilities.

DukaanVikaas: Offline Kirana AI Billing

Harshit Agarwal — Thu, 15 Oct 2026 15:08:01 +0000

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

What I Built

DukaanVikaas (दुकान विकास) is a 100% browser-native, offline-first inventory and point-of-sale (POS) billing application crafted specifically for India's 12+ million neighborhood Kirana stores and micro-retailers.

It enables shopkeepers to record sales using conversational, regional language commands (such as "5 packet Maggi bike", "3 Thums Up sell thai", "2 packet biscuit bech diye", or compound sentences like "Aaj 5 packet Maggi aur 3 cold drink bike"). It tracks inventory levels atomically, warns against stockouts, generates dynamic revenue analytics, supports instant one-click bill reversals with compensating return audit logs, and allows offline versioned JSON backups—all running with zero latency directly within the merchant's browser.

Who Would Pay For It & What Problem Does It Solve?

The Problem: Small Indian Kirana stores operate on razor-thin margins in fast-paced retail environments, often in semi-urban or rural areas plagued by erratic power and intermittent internet. Traditional enterprise billing software (like Tally, Marg, or Vyapar) is expensive, hardware-dependent, clunky, and overwhelmingly English-first. Conversely, cloud-only SaaS apps crash when the internet drops in the middle of a rush-hour customer queue.
The Solution: DukaanVikaas requires zero server backend, zero cloud databases, zero API keys, and zero subscription fees. It runs on any inexpensive Android smartphone, tablet, or desktop browser.
Who Pays / Economic Value: Small retailers, FMCG distributors, and micro-merchants save thousands of rupees in monthly software subscriptions, hardware POS rentals, and lost revenue from network downtime.

Demo

🌐 Live Deployed Application: https://dukaan-vikaas.vercel.app/
💻 GitHub Repository: https://github.com/Harshitagarwal113/DukaanVikaas

Key Workflows to Explore in the Demo:

Natural Language Assistant: Tap "AI Bill Entry" on the dashboard. Click sample prompts like "5 packet Maggi bike" or "3 Thums Up sell thai", parse the command, observe automatic price derivation and stock check, and explicitly confirm the sale.
Ambiguity Safety Guard: Try typing an ambiguous command like "2 cold drink bike". Notice that the engine never silently guesses—it identifies candidates (Thums Up, etc.), prompts for exact confirmation, and disables checkout until verified.
Instant Multilingual Switching: Switch between हिन्दी (Hindi), ગુજરાતી (Gujarati), Hinglish, and English via the top header selector with zero page reload.
Stock Integrity & Sale Reversal: Navigate to Sales History, inspect any completed receipt, and click Reverse Sale. Watch the item atomically return to inventory stock, an audit trail movement generated with reason 'return', and today's revenue recalculate dynamically.
JSON Backup & Restore: Open Settings, download dukaan-vikaas-backup.json, inspect the schema validation, or preview before restoring.

Code

Harshitagarwal113 / DukaanVikaas

DukaanVikaas — Browser-Native Kirana Store Inventory & Sales Manager with Offline Simulated NLP

DukaanVikaas (दुकान विकास) 🛒🌾

A minimal, high-performance, browser-native Kirana inventory and point-of-sale billing web application designed specifically for Indian neighborhood retail stores.
Built with an offline-first architecture powered completely by client-side IndexedDB, deterministic simulated natural-language transaction parsing, and browser-native JSON backups.

🌐 Live Application: https://dukaan-vikaas.vercel.app/
📦 GitHub Repository: https://github.com/Harshitagarwal113/DukaanVikaas

📖 Table of Contents

💡 Core Philosophy

Traditional retail SaaS platforms require continuous high-speed internet, monthly cloud subscription fees, complex authentication, and external databases that fail when network connectivity drops in rural or semi-urban areas.

DukaanVikaas is…

View on GitHub

The entire codebase is open-source, strictly typed, and structured into clean, modular layers:

lib/ai/simulatedParser.ts: 100% offline deterministic rule-based natural language parser with multilingual tokenizers, phonetic alias matching, and candidate suggestion guards.
lib/storage/db.ts: Client-side IndexedDB multi-store architecture with atomic transactional integrity and signed audit movement logs.
lib/validation/index.ts: Pre-import backup validator preventing corrupt schemas, negative pricing, and duplicate IDs.
lib/i18n/LanguageContext.tsx: Persistent vernacular state engine with memoized synchronization across local storage and IndexedDB.
tests/runUnitTests.ts: 45-point automated test suite validating the NLP parser, business math, and schema integrity.

How I Built It

Rather than relying on heavy, black-box cloud LLM APIs—which charge per token, introduce latency, require internet access, and risk catastrophic hallucinations in financial accounting—DukaanVikaas was designed around an open-source, client-side deterministic NLP engine and local-first architecture:

1. Local Deterministic NLP Engine

Conversational Tokenizer: Cleans regional conversational prefixes (aaj, bhaiya, sethji, sun, please) and verb suffixes (bike, bika, bech diye, sell thai, vechya, aapi).
Multilingual Numeral Normalization: Maps written number words in Hindi, Gujarati, Devanagari, and English (teen, paanch, tran, દો, પાંચ, five) and fractional terms (aadha, half) to numbers.
Compound Sentence Parser: Splits compound commands via regional conjunctions (aur, and, ane, तथा, commas) into separate transaction line items.
Fuzzy Catalog & Alias Scoring: Matches items against product names, categories, and vernacular aliases (मैगी, આટા, Desh Ka Namak).
Zero-Guess Ambiguity Guard: If an input is ambiguous (e.g. general terms like "biscuit" or "cold drink"), the engine classifies the item as needs_clarification, presents quick-pick buttons, and blocks checkout until the merchant explicitly confirms the item.

2. Browser-Native Storage & Tech Stack

Next.js 16 (App Router + Turbopack) & React 19: Ultra-fast client rendering with sub-second hot reload and zero build bloat.
Tailwind CSS v4: Minimalist Forest Green retail SaaS aesthetics (#065f46), high-contrast charcoal typography, neutral borders, and touch-optimized buttons ($\ge 44\text{px}$).
Browser-Native IndexedDB: 5 transactional object stores (products, sales, inventoryMovements, settings, metadata) providing offline durability.
Native JSON Blob Backup: Browser-triggered downloads without file system vulnerabilities or arbitrary disk access claims.

Why Does Open Innovation Matter?

Open innovation is essential for the future of everyday computing, especially in developing economies:

Digital Sovereignty & Absolute Privacy: A shopkeeper's daily revenue, wholesale margins, customer credit (khata) records, and supplier relationships are their most confidential business data. Closed cloud platforms harvest and monetize this data. With DukaanVikaas's open client-native architecture, 100% of data stays inside the merchant's physical browser—no server logs, no tracking, and zero leakage.
Resilience Against the "Always-On" Myth: Big tech software often assumes continuous gigabit fiber and reliable power. Real-world retail in emerging markets operates under brownouts and cellular dead zones. Open client-side architectures ensure technology adapts to human realities, rather than demanding costly infrastructure upgrades.
Zero Financial Friction & True Democratization: Closed AI services lock users into recurring token billing and subscription tiers. Open, browser-executable logic costs $0.00 to run. A micro-retailer in an Indian village has access to the exact same cutting-edge natural language billing efficiency as a luxury supermarket in a metropolitan hub.
Predictability Over Hallucination: Closed LLMs are probabilistic—they can miscalculate currency, hallucinate prices, or invent inventory items. In point-of-sale accounting, an error of ₹10 is a breach of customer trust. Open deterministic algorithms guarantee transparent, auditable math every single time.

My Agent Session

This application was developed as a solo engineer using paired agentic software engineering with DeepMind's Antigravity IDE and DevRelay:

Test Automation: Used subagents to perform end-to-end browser QA across mobile viewports (390x844), tablet screens, and desktop layouts.
Continuous Validation: Executed automated unit tests (45/45 passed), strict ESLint checks, and production builds with zero warnings.
Session Record: The full autonomous workflow, code edits, browser verification runs, and Git commit trails were orchestrated and verified end-to-end locally.

My First User

During development, DukaanVikaas was demonstrated to Ramesh-ji, an independent Kirana store owner operating a neighborhood provision shop:

The Reaction: "Ye to badiya hai! Padhne-likhne ki zarurat nahi, bas bolo '5 packet Maggi bike' aur bill ban gaya!" ("This is great! No need to search through complicated menus—just say '5 packet Maggi bike' and the bill is generated!").
Key Insight: He particularly appreciated that the app worked in Hindi and Gujarati without lagging, and that he could back up his complete shop data to a data.json file on his phone whenever he wanted, giving him complete peace of mind that no cloud company could ever lock him out of his records.

Prize Categories

Participation: Solo Developer (Harshit Agarwal / @Harshitagarwal113)

Open Source AI / Local-First Innovation: For building an offline, deterministic, zero-cloud natural language retail interface running 100% client-side in the browser.
Tech for Good & Social Impact: For empowering unserved micro-retailers (Kirana stores) with free, localized, accessible billing software that requires no expensive hardware or subscriptions.
Web Applications / Edge Computing: For showcasing Next.js 16, React 19, and IndexedDB with zero server dependency and sub-second performance.

OutsideQuest AI: Screen-Free Nature Quests with On-Device Gemma 3

Harshit Agarwal — Sun, 11 Oct 2026 13:32:47 +0000

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

What I Built

Most modern technology traps us in continuous dopamine loops, screen fatigue, and doomscrolling. Even outdoor apps often exacerbate this problem by demanding continuous screen interaction—staring at turn-by-turn navigation, checking GPS maps, or curating photos for social validation.

OutsideQuest AI was built to do the exact opposite: use lightweight, open-weight AI to inspire you to put your phone in your pocket and touch grass.

OutsideQuest AI is an intelligent, privacy-first companion that creates personalized outdoor micro-adventures designed for sensory immersion in living nature. Whether you have 15 minutes between remote work meetings or an hour on the weekend, the app crafts a structured, grounding outdoor mission tailored to:

Available Time: 15, 30, 45, or 60 minutes.
Immediate Landscape: Neighborhood, city park, botanical garden, university campus, or wild forest trail.
Sensory Mood & Movement Pace: Curious, calm, energetic, or social; gentle, moderate, or active.
Companion Mode: Solo mindful walks, friends, family with children, or community groups.
Sensory Interests: Birding & bird song, plant identification, walking rhythms, mindfulness, tactile exploration, or nature photography.
Accessibility Needs: Step-free pathways, flat terrain, frequent rest benches, and sensory-friendly options.

The Screen-Free Philosophy: Phone Away, Adventure On

Once your quest begins, OutsideQuest AI encourages you to keep your screen off:

Paced Audio Chimes: Built-in Web Audio API synthesizers play gentle harmonic chimes (528 Hz and 659 Hz) to signal when each sensory milestone concludes, so you never have to watch a ticking clock.
Sensory Focus Prompts: Every step activates a distinct physical sense—listening for rustling foliage, noticing bark textures, feeling temperature gradients, or tracking shadow angles.
Safety-First Guardrails: The engine programmatically enforces strict nature safety rules: no eating wild plants/mushrooms, no approaching or handling wildlife, and staying on marked public paths.
Nature Journal & Reflections: When you return, you record what you noticed (sensory observations, bird sightings, mental headspace) in a private, persistent nature journal stored locally in your browser.

Demo

🌐 Live Web Application: https://outside-quest-ai.vercel.app/
⚡ Zero Setup Required: Deployed on Vercel with zero required API keys, accounts, or environment variables. Works on desktop, tablet, and mobile browsers.

Code

📦 GitHub Repository: https://github.com/Harshitagarwal113/OutsideQuest-AI
📄 License: MIT License (Open Source)
🏷️ Current Release: v0.1.0

Harshitagarwal113 / OutsideQuest-AI

OutsideQuest AI 🌲

Turn routine neighborhood walks into sensory outdoor micro-adventures with browser-native, open-weight AI.
Built for the Touch Grass Open-Source AI Challenge.

🧭 Product Overview

In an era of hyper-connected screens and infinite AI chat loops, OutsideQuest AI was built to turn artificial intelligence inside out: instead of capturing your gaze, it encourages you to pocket your phone and explore the living world with your physical senses.

OutsideQuest AI runs open-weight Small Language Models (SLMs) directly inside the user's browser via WebGPU and WebAssembly. It personalizes sensory exploration missions tailored to your immediate environment (park, garden, neighborhood, campus), available duration (15 to 60 minutes), social setting (solo, friends, family), mood, and accessibility preferences.

Every quest is private, free, and self-contained:

Zero Cloud Inference APIs: No OpenAI, Anthropic, or external serverless endpoints.
Zero Account Creation: No login walls, passwords, or tracking cookies.
Zero Ongoing Cost: Hosted on Vercel Hobby (Free…

View on GitHub

How I Built It

OutsideQuest AI runs an open-weight Small Language Model directly in the user's browser—no cloud GPU clusters, no external inference APIs, and no server-side execution.

1. On-Device AI Engine: Google Gemma 3

Model: onnx-community/gemma-3-270m-it-ONNX (Google Gemma 3 270M Instruction-Tuned).
Quantization: 4-bit INT4 (q4) weights (~200 MB download footprint), optimized for consumer mobile devices and laptops.
Inference Library: Transformers.js v3 (@huggingface/transformers) coupled with ONNX Runtime Web.
Hardware Acceleration: Automatically targets WebGPU for parallel tensor arithmetic on device silicon, with graceful degradation to multi-threaded WebAssembly (WASM).

2. Multi-Threaded Web Worker Architecture

Running heavy neural network matrix calculations on the browser UI thread can freeze scrolling and animations. We isolated the model lifecycle inside a dedicated Web Worker (src/features/ai/workers/model.worker.ts):

Non-blocking token generation keeps the React user interface at a butter-smooth 60 FPS.
Dynamic Gemma chat template handling formats prompt turns and seamlessly handles system-prompt merging.
Comprehensive progress tracking reports byte-level download and shader compilation progress back to the UI.

3. Dual-Engine Generation & Zero-Drop Resilience

To guarantee that you can always head outside even with zero connectivity:

Primary Generator: Browser-native Google Gemma 3 neural generation.
Deterministic Curated Engine: If the model has not yet been downloaded, or if you are already on a deep trail with cellular reception turned off, a deterministic engine instantly generates rich, sensory-grounded quests in 0 milliseconds with 0 MB downloaded.

4. Local-First Nature Journaling with IndexedDB

Your thoughts and reflections are stored in a sandboxed, client-side database using idb (IndexedDB):

Quests, completion statuses, sensory notes, and nature metrics persist across browser sessions.
Built-in data export (formatted JSON) and print-ready expedition note summaries.

Tech Stack Summary

Framework: Next.js 14 App Router (Full static prerendering)
Language & Runtime: TypeScript (Strict Mode) + React 18
Styling: Tailwind CSS with a curated, nature-inspired palette (Forest, Sage, Sand, Earth Amber)
Validation: Zod schemas for runtime parameter checking and LLM JSON output repair
Audio: Custom Web Audio API synthesizer for serene nature chimes
Testing: 15 Vitest test suites (71 tests passing) + Playwright E2E suites for desktop and mobile viewports

Why Does Open Innovation Matter?

Outdoor exploration and nature connection should be universal, safe, and free. Building OutsideQuest AI around an open-weight, browser-native model unlocks benefits that closed, proprietary cloud APIs simply cannot match:

True Offline Functionality in Living Nature:
Closed APIs require constant high-speed internet. But the best places to "touch grass"—state parks, botanical gardens, coastal headlands, and dense woodlands—often have spotty or zero cellular coverage. Because Gemma 3 is cached on-device, OutsideQuest AI continues generating adventures even when completely disconnected in Airplane Mode.
Absolute Privacy & Data Sovereignty:
Closed APIs log your prompts, location hints, daily walking routines, physical limitations, and sensory reflection journals onto commercial cloud servers. With open weights on-device, your thoughts and personal context never leave your browser sandbox.
Zero Cost & Democratic Access:
There are no token costs, subscription tiers, API credit expirations, or paywalls. Anyone with a smartphone or laptop can experience personalized nature guidance without entering a credit card or registering an account.
Reliability & Immortality:
A closed API can be sunset, rate-limited, or altered overnight. An open-weight model with an open-source web application remains fully operational forever.

My Agent Session

This application was engineered collaboratively with Antigravity AI, Google DeepMind's agentic coding pair programmer.

The full agent workflow covered:

Architecting the client-side Web Worker communication layer and Zod output repair pipeline.
Integrating onnx-community/gemma-3-270m-it-ONNX via Transformers.js v3 with WebGPU/WASM fallback.
Conducting rigorous security and code audits, resolving PostCSS configurations, and achieving 100% test pass rates across 71 unit/integration tests.
Deploying the static bundle to Vercel Hobby with zero environment variables and zero paid compute.

(Transcripts and architecture documents are preserved directly in the repository under docs/ARCHITECTURE.md and docs/AI_DECISIONS.md).

Prize Categories

We are entering OutsideQuest AI into the following track:

Best Use of Gemma (Primary Partner Category)
Grand Prize / Overall Track (Hacktoberfest Open-Source AI Challenge: Week 1 — Touch Grass)

🌲 Step Outside

OutsideQuest AI proves that open-source AI doesn't have to keep us glued to glowing rectangles. By taking advantage of Google Gemma 3 running on your device silicon, we can use artificial intelligence to celebrate and preserve our connection with the real, tactile, beautiful natural world.

Take 15 minutes today, put your phone in your pocket, and go explore:
👉 Launch OutsideQuest AI

The Comeback of Agent Baymax: From Hackathon Prototype to AI Healthcare Platform

Harshit Agarwal — Sat, 06 Jun 2026 09:17:20 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

🩺 Agent Baymax V2 — From a Local AI Assistant to a Full Healthcare Platform

What I Built

Some projects don't need to be replaced—they need to be completed.

Agent Baymax started as a simple terminal-based healthcare companion built during a hackathon. The original version could answer basic health-related questions, log calories, track hydration, and maintain short-term conversational context using a locally running language model.

While the idea worked, it never fully matched the vision I had in mind.

Users had to manually enter meals, there was no personalization across sessions, no visual interface, no image understanding, and no way to retrieve information from trusted healthcare resources.

For the Finish-Up-A-Thon Challenge, I decided to revisit the project and transform it into something much more capable.

The result is Agent Baymax V2 — an AI-powered healthcare companion that combines:

🧠 Conversational AI
📸 Multimodal meal analysis
🍽️ Personalized nutrition planning
🧮 Dynamic BMR and TDEE calculations
📚 Retrieval-Augmented Generation (RAG)
💾 Long-term memory extraction
🔐 Secure authentication
☁️ Cloud-based storage and data management

What started as a simple terminal application evolved into a modern healthcare platform designed around personalization, accessibility, and intelligent health tracking.

Demo

This project is currently under active development and is being demonstrated through screenshots.

Dashboard

The redesigned dashboard provides users with a modern healthcare experience featuring personalized health metrics and quick access to Baymax's capabilities.

AI Healthcare Assistant

Users can chat naturally with Baymax and receive contextual health guidance powered by Gemini.

Vision-Based Meal Analysis

Users can upload meal images and receive calorie estimates, macro breakdowns, health scores, and nutritional insights.

Personalized Health Metrics

Baymax dynamically calculates BMR, TDEE, protein targets, and daily nutrition recommendations based on the user's profile.

Knowledge Base & RAG

Healthcare documents can be uploaded, embedded, and searched to provide evidence-based responses grounded in trusted resources.

The Comeback Story

The original Agent Baymax was built as a lightweight proof of concept.

Version 1 used Google's Gemma 2B instruction-tuned model running locally through Hugging Face Transformers. Users interacted through a terminal interface where they could ask basic health questions, track hydration, and log food consumption.

Although functional, several limitations quickly became apparent:

No graphical user interface
No authentication system
No persistent memory
No image understanding
No document retrieval
No personalization engine
No scalable architecture

Rather than abandoning the project, I chose to rebuild it from the ground up.

The first major step was moving from a terminal application to a modern web platform powered by Next.js and Supabase.

Next came multimodal AI capabilities. Instead of manually logging food, users can now upload meal images and receive structured nutritional analysis.

To improve personalization, I implemented a memory extraction system that identifies important long-term user preferences, dietary restrictions, and lifestyle choices and stores them for future interactions.

I then introduced a Retrieval-Augmented Generation pipeline using embeddings and vector search, allowing Baymax to retrieve information from uploaded healthcare documents instead of relying entirely on model knowledge.

Finally, I redesigned the user experience with glassmorphic interfaces, smooth animations, streaming AI responses, cloud storage, authentication, and scalable backend infrastructure.

Before vs After

Agent Baymax V1	Agent Baymax V2
Terminal-Based Application	Modern Web Platform
Local Gemma 2B Model	Gemini-Powered AI
Text-Only Inputs	Text + Image Understanding
Local File Storage	Cloud Database
Session Context Only	Persistent Long-Term Memory
Manual Food Logging	AI Meal Recognition
No Knowledge Retrieval	RAG + Vector Search
Single-User Local Tool	Scalable Full-Stack Platform

This challenge became less about finishing unfinished code and more about finishing the original vision behind Baymax.

My Experience with GitHub Copilot

As the project grew from a small Python prototype into a full-stack AI application, development complexity increased significantly.

GitHub Copilot helped speed up implementation by assisting with:

API integrations
Authentication flows
Database operations
TypeScript interfaces
React component scaffolding
Utility functions
Backend route generation

For larger features such as memory extraction workflows and vector search integrations, Copilot provided useful starting points that accelerated experimentation and iteration.

Rather than replacing problem-solving, it reduced repetitive work and allowed more focus on architecture decisions, feature design, and user experience.

🛠️ Tech Stack

Frontend

Next.js 16
React 19
Tailwind CSS v4
Framer Motion

Backend & Database

Supabase PostgreSQL
pgvector
Supabase Auth
Supabase Storage

AI & Machine Learning

Google Gemini
Google Embedding Models
Vercel AI SDK

Infrastructure

Upstash Redis
Vector Search
Retrieval-Augmented Generation (RAG)
Long-Term Memory Engine

Final Thoughts

Revisiting Agent Baymax taught me an important lesson.

Not every unfinished project deserves to be abandoned. Sometimes the most rewarding challenge is returning to an old idea and finally building it the way you originally imagined.

Agent Baymax began as a small hackathon experiment.

Agent Baymax V2 represents the vision that experiment was always meant to become.

And this challenge gave me the perfect excuse to finally finish it.

Gemma Wagon - Your Private Ambient AI Desktop Companion Powered by Gemma 4

Harshit Agarwal — Tue, 19 May 2026 17:31:11 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Gemma Wagon

Executive Summary

Gemma Wagon is a privacy-first, fully local AI desktop assistant designed to transform how users interact with their computers. Instead of functioning as a simple chatbot, Gemma Wagon acts as an intelligent operating system layer capable of seeing the user’s screen, understanding voice commands, reasoning through complex workflows, and executing real desktop actions — all without sending data to the cloud.

Built around the multimodal and agentic capabilities of Gemma 4, Gemma Wagon combines local inference, real-time desktop context awareness, Retrieval-Augmented Generation (RAG), and secure OS-level automation into a single unified experience.

Our goal is to bridge the growing gap between AI utility and user privacy. Current AI assistants often require constant internet connectivity and expose sensitive information to external servers. Gemma Wagon solves this problem by ensuring every interaction happens entirely on-device.

This project demonstrates how Gemma 4 can power the next generation of ambient AI systems that are fast, secure, context-aware, and developer-friendly.

The Problem

Modern AI assistants are powerful, but they still suffer from several major limitations:

Sensitive files and screen data must often be uploaded to external servers
Existing assistants lack persistent contextual awareness of the desktop environment
Local AI solutions are fragmented and difficult for non-technical users
Most assistants cannot safely execute real operating system tasks
Cloud dependency introduces latency, privacy concerns, and internet requirements

Users need an AI system that is:

Local-first
Privacy-preserving
Multimodal
Action-oriented
Lightweight enough to run continuously

Gemma Wagon was designed specifically to solve these challenges.

Our Solution: Gemma Wagon

Gemma Wagon introduces an Ambient AI Desktop Layer that continuously assists users through contextual understanding and local reasoning.

The system includes:

Persistent floating AI overlay (“Orb”)
Local multimodal reasoning using Gemma 4
Voice + screen understanding
OS-level task automation
Local REST API for developers
Offline document intelligence using RAG
Fully private local execution

Instead of forcing users to switch between applications, Gemma Wagon becomes a natural extension of the desktop itself.

Why Gemma 4?

Gemma 4 is the core technology that makes this architecture possible.

1. Native Multimodality

Gemma 4 can process:

Text
Images
Audio

This enables Gemma Wagon to:

Understand screenshots
Analyze UI elements
Process voice commands
Maintain contextual awareness

The multimodal capabilities allow the assistant to “see” and “hear” the user’s environment in real time.

2. Efficient Local Inference

We use optimized GGUF variants of Gemma 4 running through llama.cpp.

This allows:

Fully offline inference
GPU acceleration
Low memory usage
Background execution without disrupting workflows

The Mixture-of-Experts efficiency of Gemma 4 enables high-quality reasoning while remaining lightweight enough for local consumer hardware.

3. Massive Context Window

Gemma 4’s extended context capabilities allow Gemma Wagon to:

Read large PDFs
Analyze repositories
Understand long conversations
Process entire document libraries

This becomes especially powerful when combined with our local RAG pipeline.

4. Agentic Reasoning & Function Calling

Gemma 4’s reasoning capabilities enable safe desktop automation through structured function calls.

Examples include:

Opening applications
Finding files
Organizing folders
Summarizing spreadsheets
Running scripts

The assistant reasons before acting, making automation safer and more reliable.

Technical Architecture

Gemma Wagon is built using a layered architecture optimized for performance, security, and modularity.

1. Core Engine (Python/Rust)

The Core Engine acts as the brain and system controller.

Responsibilities

Screen capture
Audio capture
OS integrations
Function execution
REST API handling

Key Technologies

Python
Rust
mss for screenshots
pyaudio for microphone streaming

The engine runs locally as a background service and exposes an OpenAI-compatible local API endpoint.

2. AI Inference Layer

The inference layer embeds Gemma 4 directly into the application.

Key Implementation Details

GGUF model format
llama.cpp backend
CUDA acceleration
Vulkan/ROCm support
Metal support for macOS

Optimizations

KV-cache memory management
Context retention
Inference throughput
Local GPU utilization

This enables real-time AI interaction directly on-device.

3. Frontend (Tauri + Rust)

The frontend provides the desktop experience.

Features

Floating Orb overlay
Modern chat interface
Markdown rendering
Model configuration
Document management

Why Tauri?

Smaller binaries
Better performance
Higher security
Native desktop integration

Rust handles secure communication between the UI and backend systems.

4. Local Knowledge Base (RAG)

Gemma Wagon includes fully local document intelligence.

Pipeline

Document upload
Chunking
Embedding generation
Vector indexing
Retrieval during inference

Supported Documents

PDFs
PPTs
Notes
Codebases

The vector database uses lightweight local storage for fully offline retrieval.

Communication Flow

The interaction pipeline follows this sequence:

User triggers Gemma Wagon via voice or hotkey
System captures screen/audio context
Gemma 4 processes multimodal input
AI generates either:
- A response
- A function call
Core Engine executes the action
UI provides visual feedback

This architecture enables real-time ambient assistance while remaining fully local.

Privacy & Security

Privacy is the foundation of Gemma Wagon.

Security Model

Fully local inference
No cloud processing
No telemetry
Encrypted local storage
Sandboxed OS function execution

The only internet access required is the initial model download.

Ideal For

Developers
Enterprises
Researchers
Privacy-conscious users

Key Use Cases

Productivity Assistant

“Summarize this spreadsheet and generate action items.”

Developer Copilot

“Analyze this repository and explain the architecture.”

Smart Document Search

“Find the PDF where I discussed vector databases.”

Workflow Automation

“Open VS Code, launch Docker, and summarize yesterday’s notes.”

Accessibility Support

Context-aware voice-based desktop interaction.

Engineering Challenges

Real-Time Multimodal Processing

Running continuous screen + audio analysis locally required careful optimization of:

GPU memory
Context management
Inference latency

Safe Function Calling

We implemented controlled execution pipelines to prevent unsafe automation behavior.

Lightweight Desktop Integration

Creating a persistent desktop assistant without large resource consumption required deep optimization using Rust and Tauri.

Local RAG Performance

Efficient indexing and retrieval were essential for maintaining fast response times on consumer hardware.

What Makes Gemma Wagon Different?

Unlike traditional AI chat applications, Gemma Wagon is:

Ambient instead of reactive
Local instead of cloud-based
Agentic instead of passive
Multimodal instead of text-only
Integrated into the OS instead of isolated in a browser tab

Gemma Wagon demonstrates how Gemma 4 can power truly personal AI systems that remain private, fast, and deeply contextual.

Conclusion

Gemma Wagon represents a new category of AI-native computing.

By combining:

Gemma 4 multimodal reasoning
Local inference
Agentic automation
Desktop integration
Privacy-first architecture

we created a system that transforms AI from a chatbot into a true operating system companion.

This project showcases the real-world potential of Gemma 4 as the foundation for next-generation ambient AI experiences that users can fully trust.

Repository

🔗 GitHub:

https://github.com/Harshitagarwal113/gemma_wagon