DEV Community: Shreyas Guha Neogi

TerraScout : Offline Nature Quest

Shreyas Guha Neogi — Sun, 11 Oct 2026 18:21:01 +0000

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

What I Built

hyper-local digital naturalist, designed to reverse the "doomscrolling" trend and get people into the woods.

Instead of acting as a generic map or a chatty assistant, TerraScout generates a personalized "Nature Quest" (e.g., Find a red oak leaf, Spot a local songbird, Locate a quartz rock) based on your selected location. Once you hit the trail, the app is designed to be pocketed. The core feature is the Offline Field Guide: If you spot something interesting or need a hint to complete your quest, you can ask the app in natural language. Because the AI runs entirely locally in the browser memory, you can get instant answers deep in the woods or canyons where cellular service drops to zero. The screen is strictly a tool to facilitate physical exploration, not the destination itself.

Code

shrguhaneogi-pixel / terrascout

How I Built It

TerraScout was built within a highly constrained timeframe using the Google AntiGravity multi-agent IDE.

The Tech Stack & Open-Source AI:

Local AI Inference (The Core): The Offline Field Guide is powered by WebLLM leveraging the WebGPU API. It runs the open-weight gemma-2-2b-it-q4f16_1-MLC model entirely locally on the user's device (phone or laptop). The model is cached in IndexedDB via Service Workers, allowing it to initialize without a network connection.

Frontend PWA: Built with Next.js 16 (App Router) and Tailwind CSS. I used next-pwa to ensure the application shell caches correctly for offline reopening.

Backend & Data (The Pre-Hike Phase): Hosted on Render (frontend) and DigitalOcean (backend microservices). When the user is still on Wi-Fi, the app uses SerpApi to check trail conditions and TabPFN to analyze local tabular weather datasets (stored in TigerData) to predict the most likely flora/fauna to generate the quest. The AI orchestration was mapped using Entire.

Database & Dashboard: Completed quests sync back to MongoDB Atlas when the user reconnects, managed via a Backboard admin panel.

Development Tools: Rapidly prototyped the Gemma prompts using Tinker, and accelerated the Next.js boilerplate using GitHub Copilot alongside AntiGravity.

Why Does Open Innovation Matter?

By utilizing open-weight models like Gemma 2B and open frameworks like WebLLM, TerraScout achieves three things closed systems cannot:

Zero-Connectivity Execution: You can take the AI miles away from a cell tower. It processes your questions instantly on your device's GPU.

Absolute Privacy: Your location, queries, and trail habits never hit a remote server while you are exploring.

Zero Inference Cost: I don't pay a cent for API calls when users are chatting with the field guide on the trail.

My Agent Session

Google AntiGravity's autonomous agent workflows to handle the WebGPU boilerplate and Next.js PWA configuration.

TerraScout — Offline Nature Quest PWA Autonomous Build & Verification gemma-2-2b-it-q4f16_1-MLC

You

Execute the autonomous build plan to implement TerraScout, a production-minded offline nature quest PWA. Spawn parallel subagents for terminal operations, file editing, and browser validation. Prioritize functional code, local WebGPU inference, and a highly polished mobile-first UI.

Critical Constraint: Do not claim a feature works unless you have implemented and verified it. Do not hallucinate API keys, remote backend dependencies, or unsupported WebLLM features.

Phase 0: Repository Initialization & Version Control
Phase 1: Environment Audit & Dependency Resolution
Phase 2: Core UI & Mock Quest Engine (app/page.tsx)
Phase 3: WebLLM Integration (Real Local Inference)
Phase 4: Validation & Finalization

Agent

Implemented and verified TerraScout, an offline nature scavenger hunt and wilderness reconnaissance Progressive Web Application (PWA) with on-device WebGPU inference via WebLLM.

Key Deliverables Across All Phases:

Phase 0 — Repository Setup & Version Control:
- Initialized Git repository with Next.js App Router structure and strict .gitignore.
- Enforced Scheduled Commit Protocol with atomic commits for each phase (86efaa5, c7ffeff, d25fcfb, 60c7a7e, dad71b2, 58b1234).
Phase 1 — Dependencies & PWA Offline Shell:
- Installed @mlc-ai/web-llm and configured @ducanh2912/next-pwa in next.config.mjs with 15MB cache limits to precache WebAssembly runtimes and the app shell.
- Generated PWA manifest.json and standalone icons (192x192, 512x512).
Phase 2 — Core UI & Mock Quest Engine:
- Built a mobile-first dark earthy backcountry palette (Deep Pine, Moss, Sage, Parchment).
- Implemented controlled location input with real-time validation and preset trailheads.
- Built procedural quest engine (lib/questEngine.ts) returning three contextual items per biome (Coniferous, Coastal, Montane, Desert, Urban, Woodland).
- Built interactive checklist with accessible checkboxes (role="checkbox", aria-checked) and real-time progress calculation.
- Added dedicated 4-card Offline Field Guide handbook.
Phase 3 — WebLLM On-Device WebGPU Inference:
- WebGPU capability detection with graceful fallback UI for unsupported browsers.
- Integrated CreateMLCEngine with primary target model gemma-2-2b-it-q4f16_1-MLC and low-memory Qwen2.5-0.5B-Instruct-q4f16_1-MLC fallback.
- Real-time initProgressCallback displaying true progress percentage and compilation stages.
- Silent system prompt injection (max 2 sentences, scout guidelines) with chat history sanitization.
- Functional state updates appending streaming tokens incrementally.
Phase 4 — Validation & Testing:
- Automated Unit Tests: 10/10 tests passed (npm test).
- Typecheck & Lint: Zero errors, zero warnings (tsc --noEmit, next lint).
- Production Build: Compiled cleanly with prerendering and service worker generation (npm run build).
- End-to-End Browser QA: Verified responsive viewports, validation edge cases, quest generation, checklist progress, and WebGPU detection.
- Comprehensive documentation in TERRASCOUT_SUMMARY.md.

▸ unit_tests npm test

Input

npm test

Output

10 passed, 0 failed, 0 skipped, duration 355ms

▸ static_analysis npm run typecheck && npm run lint

Input

npm run typecheck && npm run lint

Output

tsc --noEmit: exit 0; next lint: No ESLint warnings or errors

▸ production_build npm run build

Input

npm run build

Output

Next.js production build compiled successfully, service worker generated at /sw.js

▸ browser_qa_validation browser subagent on http://localhost:3000

Input

browser subagent on http://localhost:3000

Output

Responsive mobile/desktop layouts verified, location validation passed, quest generation verified, checklist progress tracking verified, WebGPU detection verified

Prize Categories

Github Copilot
Render
Tinker
Gemma

📖 LocalHost Journaling ✍️With Gemma

Shreyas Guha Neogi — Sun, 04 Oct 2026 18:09:26 +0000

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

What I Built

I built Space Journal - an Offline "Safe-Space" Cognitive Journal Analyzer for my friend, Risiraj, who suffers from panic attacks and manages anxiety through journaling and is a poet at heart, but is fiercely protective of their privacy.

It is a completely offline zero-telemetry environment where my friend can securely paste their daily inflections without a permanent online imprint or embarassment.

Demo

Code

shrguhaneogi-pixel / spaceJournal

Offline Safe-Space Journal Analyzer

A privacy-first, 100% offline desktop application designed for safe, personal journal reflection using an open-weight model running entirely on your own machine.

Quick Start (3 Easy Steps)

Step 1: Install Ollama & Pull Model

Download and install Ollama for your operating system.
Open your terminal / command prompt and download the local AI model:
```
ollama pull gemma2:2b
```

Step 2: Install Python Dependencies

Open your terminal in this directory and install the dependencies:

pip install -r requirements.txt

Step 3: Launch the Application

Start the application with a single click or command:

Windows: Double-click start_journal.bat (or run start_journal.bat in Command Prompt).
Mac / Linux: Execute ./start_journal.sh (run chmod +x start_journal.sh first if necessary).

Automated Infrastructure Sync

To schedule daily background backups of application code changes (excluding all private user data):

Windows (Task Scheduler)

Run this command in an Administrator Command Prompt (update directory path if needed):

schtasks /create

…

View on GitHub

How I Built It

I used an autonomous agent (Antigravity) to scaffold the project with strict privacy constraints. The core stack relies entirely on local execution:

Model: Google's Gemma (gemma2:2b), an open-weight model small enough to run fast on a standard laptop CPU.

Inference: Ollama, serving the model locally.

Frontend: Streamlit for a clean, minimalist user interface.

Prototyping: Google AI Studio to perfect the system prompt for objective, non-judgmental cognitive reframing before writing any code.

Antigravity generated idempotent deployment scripts (start_journal.sh / .bat) so my non-technical friend can launch the Ollama server and the Streamlit app with a single click. It also generated a strict .gitignore that physically blocks local caches and journal data from ever being committed, ensuring only the infrastructure is synced to the private repository.

Why Does Open Innovation Matter?

For deeply personal mental health tools, open innovation isn't just a feature—it's the only way the product can exist.

If this relied on a closed API, my friend simply wouldn't use it. By leveraging an open-weight model, I was able to guarantee absolute data sovereignty.

My Agent Session

Check out how I used Antigravity to autonomously generate the offline privacy constraints and idempotent deployment scripts:

Offline Safe-Space Journal Analyzer - Autonomous Build & Deploy

You

Build and locally deploy the Offline Safe-Space Journal Analyzer desktop web application. Core requirements: 100% offline local processing using Ollama (gemma2:2b), privacy-first zero-telemetry Streamlit app, startup scripts (start_journal.bat and start_journal.sh), zero-leakage .gitignore, and automated backup sync scripts.

Agent

Created the complete Offline Safe-Space Journal Analyzer application suite in spaceJournal workspace:

app.py: Streamlit frontend with local Ollama inference using gemma2:2b, error handling, and empathetic UI.
requirements.txt: Minimal dependencies (streamlit, ollama).
start_journal.bat & start_journal.sh: One-click startup scripts checking port 11434 before starting Ollama and Streamlit.
.gitignore: Strict privacy exclusions ignoring logs, database files, and personal journal notes.
sync_codebase.bat & sync_codebase.sh: Scoped version control backup scripts pushing infrastructure updates to GitHub.
README.md: 3-step setup and background sync scheduling instructions.

Prize Categories

Best Use of Gemma : (Ran Google's gemma2:2b open-weight model locally for offline inference)

Future of AI: Better Memory over Reasoning.

Shreyas Guha Neogi — Sat, 30 May 2026 08:39:07 +0000

This is a submission for the Hermes Agent Challenge

Most AI Agents Are Forgetful. Hermes Agent Is Betting That Memory Matters More Than Intelligence.

Every few weeks, a new AI agent framework appears. For about ten minutes, it feels revolutionary.

Then reality kicks in.

The agent forgets everything. Fancy Reasoning over lacklustre memory.

Hermes Agent is interesting because it treats intelligence as something that compounds. This changes everything.

That is the insight I would carry forward from it.

Hermes is not only about planning or tool use or multi-step reasoning, although it does those things. It is about turning repeated work into remembered work, and turning remembered work into better future work.

If the next generation of agent systems is going to matter, it will not be because they can produce a good one-off answer.

It will be because they can learn the shape of the work, keep that knowledge, and become more useful every time they are used.

Hermes is pushing in that direction.

IMO, that is why it is worth building on.

TL;DR Hermes is one of the few agent systems explicitly designed around the idea that accumulated knowledge should survive beyond a single session.