DEV Community: Balabhadra

PhantomTrace | Hacktoberfest-Week4

Balabhadra — Fri, 30 Oct 2026 22:10:09 +0000

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

What I Built

Every machine leaves a trace. Some tell a story.

When a computer or cloud server is compromised, attackers don't just disappear—they leave behind faint digital apparitions: dozens of failed authentication attempts in the dead of night, an unusual sudo session opened by a low-privileged account, a sudden backdoor user added to /etc/passwd, and an attempt to erase audit logs.

To seasoned SOC tier-3 analysts, these logs tell an obvious story. But for junior developers, sysadmins, and small open-source teams without dedicated security personnel, raw logs are intimidating walls of cryptic text. Existing SIEM tools will throw alerts, but reconstructing what happened, when it happened, and how the adversary navigated the system is agonizingly difficult.

Enter PhantomTrace 👻

PhantomTrace is an offline, privacy-first AI digital forensics investigator that resurrects suspicious system activity and conducts an autonomous digital autopsy.

Instead of another chatbot that writes Halloween ghost stories, PhantomTrace interprets the "Ghost in the Machine" theme through real-world cybersecurity:

The "Ghosts": The hidden, lingering footprints left behind by adversaries in authentication and event logs.
The "Medium": A deterministic rule-based threat engine grounded in the MITRE ATT&CK matrix that extracts and links attack sequences without hallucinating.
The "Detective": An open-weight local AI model (running via Ollama or its built-in offline reasoning engine) that interrogates the evidence, reconstructs the breach lifecycle, and writes official forensic incident reports.
The Haunted Terminal Mode: A retro CRT phosphor-green terminal where the forensic investigator narrates the intruder’s steps like a digital ghost speaking from the system bus.

Demo

GitHub Repository: https://github.com/balabhadra3141/Hacktoberfest-Week4
Interactive SOC Dashboard: http://localhost:5173
1-Click Demo Scenarios: Built-in attack datasets ready to test in 10 seconds:
- 🐧 Linux Server Breach: Multi-IP SSH brute force -> root credential acquisition -> privilege escalation -> rogue account creation (ghost_backdoor) -> crontab persistence.
- 🪟 Windows Domain Lateral Movement: Event ID 4625 brute force -> 4624 successful logon -> 4672 SeDebugPrivilege elevation -> PsExec remote execution -> wevtutil log clearing.
- 🌐 Web Server RCE: Directory traversal + SQL injection -> PHP web shell upload -> reverse shell payload execution.

Key Screens & Features in Action

SOC Overview Console: Real-time Ghost Threat Index gauge (0–100), alert severity distribution, and MITRE tactic breakdown charts.
Ghost Timeline: Interactive chronological attack reconstruction tracing the adversary's actions with color-coded severity nodes and raw log drill-downs.
AI Chat Investigator: Grounded interactive Q&A where you can ask "Was this a brute force attack?", "Which events connect in the kill chain?", or "Provide remediation steps".
Incident Report Generator: 1-click download of an official, publication-ready Incident Response PDF (generated locally via ReportLab) and structured JSON for SIEM ingestion.
Haunted Terminal: Retro cyber-terminal that types out the ghostly autopsy stream line by line.

Code

The entire codebase is open-source under the MIT License:

Hacktoberfest-Week4/
├── backend/
│   ├── main.py               # FastAPI backend with CORS, streaming, & REST endpoints
│   ├── detector.py           # Deterministic threat engine (MITRE ATT&CK mapping & scoring)
│   ├── ollama_client.py      # Ollama local LLM connector + Zero-fail offline DFIR engine
│   ├── report_generator.py   # Publication-ready PDF (ReportLab) & JSON export
│   ├── samples.py            # Pre-loaded multi-stage attack scenarios
│   └── requirements.txt      # Pure Python dependencies (FastAPI, uvicorn, reportlab)
├── frontend/
│   ├── src/
│   │   ├── components/
│   │   │   ├── Navbar.tsx            # Case status, Ghost Score pill, & engine indicator
│   │   │   ├── SOCDashboard.tsx      # Metrics, Recharts attack vectors, & alert feed
│   │   │   ├── EvidenceScanner.tsx   # 1-click scenario loader, file upload, & raw log paste
│   │   │   ├── GhostTimeline.tsx     # Chronological attack graph with MITRE tactic tags
│   │   │   ├── AIChatInvestigator.tsx# Grounded forensic investigator chat with prompt chips
│   │   │   ├── ForensicReport.tsx    # Official DFIR report, IOC table, & 1-click PDF export
│   │   │   └── HauntedTerminal.tsx   # Retro CRT cyber terminal with real-time digital autopsy
│   │   ├── types.ts                  # TypeScript interfaces for all data structures
│   │   ├── App.tsx                   # Central state & scenario orchestrator
│   │   └── index.css                 # Cyber-obsidian & spectral emerald theme
│   ├── package.json
│   └── vite.config.ts
├── samples/                          # Standalone raw sample logs
├── run.bat                           # 1-Click Windows launcher
└── README.md                         # Architecture, installation, & judge guide

You can clone and run it with one command:

git clone https://github.com/balabhadra3141/Hacktoberfest-Week4.git
cd Hacktoberfest-Week4
.\run.bat   # Or `cd backend && uvicorn main:app` and `cd frontend && npm run dev`

How I Built It

PhantomTrace combines a deterministic rule pipeline with local open-weight AI inference:

       System Logs (Linux / Windows / Web)
                      │
                      ▼
        ┌───────────────────────────┐
        │   Log Normalization &     │
        │   Deterministic Rules     │ ◄── Regex Threat Engine (MITRE T1110, T1548, etc.)
        └─────────────┬─────────────┘
                      │
        ┌─────────────▼─────────────┐
        │  Ghost Timeline Rebuilder │ ◄── Chronological Attack Sequences
        └─────────────┬─────────────┘
                      │
         ┌────────────┴────────────┐
         ▼                         ▼
┌──────────────────┐      ┌─────────────────────────┐
│ Local LLM        │      │ Grounded Fallback       │
│ (Ollama/Qwen2.5) │  OR  │ Offline Forensic Agent  │ (100% Free / Zero Setup)
└────────┬─────────┘      └────────────┬────────────┘
         │                             │
         └─────────────┬───────────────┘
                       │
       ┌───────────────┼───────────────┐
       ▼               ▼               ▼
┌──────────────┐ ┌─────────────┐ ┌───────────────┐
│ SOC Console  │ │ AI Chat Q&A │ │ PDF / JSON    │
│ & Terminal   │ │ Investigator│ │ Report Export │
└──────────────┘ └─────────────┘ └───────────────┘

1. Deterministic Grounding (Preventing AI Hallucinations)

A major risk in AI cybersecurity is hallucination—an LLM imagining an attack or inventing a fake IP address.
PhantomTrace solves this through a two-stage pipeline:

Stage 1 (Deterministic Core): detector.py uses high-speed regex pattern matching to parse Linux syslog/auth.log, Windows EVTX-exported events, and Web server access logs. It identifies confirmed threat indicators (SSH brute force, sudo elevation, rogue accounts) and tags them with official MITRE ATT&CK technique IDs (T1110.001, T1548.003, T1136.001, T1070.001).
Stage 2 (Narrative & Correlation): The local AI model receives only verified facts and timeline nodes as grounding context. The AI's job is synthesis, kill-chain correlation, and threat explanation—not guessing.

2. Local Open-Weight Inference (Ollama + Qwen2.5 / Llama 3.2)

PhantomTrace connects directly to a locally hosted Ollama instance (http://127.0.0.1:11434) using open-weight models such as qwen2.5:3b or llama3.2.

No cloud API keys required.
Zero network requests leave your machine during analysis.
Zero-Fail Fallback Engine: To ensure the project works flawlessly for any judge or developer who doesn't have Ollama installed, the backend includes an embedded deterministic AI reasoning engine. If Ollama is offline, PhantomTrace switches automatically and seamlessly to this offline agent.

3. Frontend & Visualizations

Built with React 19, TypeScript, Tailwind CSS, and Recharts:

Obsidian & Spectral Emerald Palette: A sleek Security Operations Center (SOC) theme.
Recharts Integration: Visual breakdown of MITRE ATT&CK tactics and alert severity distributions.
ReportLab Engine: Generates official DFIR incident reports in PDF format with executive summaries, IOC tables, and remediation playbooks.

Why Does Open Innovation Matter?

In digital forensics and cybersecurity, open innovation is not just a preference—it is a non-negotiable architectural requirement.

1. Absolute Privacy & Air-Gapped Operation

System logs contain some of the most sensitive data an organization possesses: private IP architectures, internal hostnames, user credentials, failed passwords, and command histories.
Sending raw production authentication logs to a proprietary, cloud-hosted closed API (like OpenAI or Anthropic) violates compliance standards (GDPR, HIPAA, SOC 2) and actively creates a new data-exfiltration risk.
With open-weight models and Ollama, PhantomTrace operates completely offline. You can disconnect your ethernet cable, turn off Wi-Fi, and run an in-depth forensic investigation on an air-gapped laptop in a data center.

2. Auditability & Grounded Transparency

Closed AI APIs are black boxes that can change, deprecate models, or alter safety guardrails overnight. In forensic investigations where evidence might be presented in court or an insurance audit, you need predictable, auditable, deterministic inference. Open-source models can be versioned, inspected, fine-tuned, and verified locally.

3. Zero Cost & Universal Accessibility

Small startups, non-profits, independent developers, and open-source maintainers cannot afford enterprise SIEM subscriptions that charge thousands of dollars per gigabyte of ingested logs. PhantomTrace proves that open-source AI and deterministic engineering can give anyone an enterprise-grade digital forensic investigator for $0.

My Agent Session

This entire application—from backend threat rules and Ollama integration to the React dashboard, timeline graph, and PDF report generator—was developed through an agentic pair-programming session with Antigravity.

The workflow:

Architectural design focusing on deterministic threat detection + local LLM grounding.
Rapid implementation of the FastAPI backend, ReportLab PDF generator, and synthetic incident logs.
Building the React + TypeScript frontend with Tailwind CSS and Recharts.
Testing live inference and verifying complete offline resilience.

The Spirit of It

The moment this project truly came alive was when we tested the Haunted Terminal Mode on the Linux Server Breach dataset:

╔══════════════════════════════════════════════════════════════════════╗
║ PHANTOMTRACE FORENSIC KERNEL v1.0.0-HACKTOBERFEST                   ║
║ Every machine leaves a trace. Some tell a story.                    ║
╚══════════════════════════════════════════════════════════════════════╝
[*] [PHANTOMTRACE] Initializing Spectral Memory Extraction...
[*] Probing kernel ring buffer and forensic event journals...
[*] Captured 14 spirit traces across system bus.
[!] DANGER: Detected 5 paranormal security deviations!
[!] Spectral Origin Located: Foreign IP entity `198.51.100.42` manifesting on port 22.
[>] Trace #1: SSH Brute Force Attack (5 attempts) [T1110.001]
    ↳ Whisper: Detected 5 failed authentication attempts originating from IP 198.51.100.42.
[💀] THE GHOST BREACHED THE GATE: Authentication barrier collapsed!
[💀] GHOST ELEVATION: The entity possessed root UID 0 permissions!
[💀] PHANTOM RESIDUE: Adversary left a rogue soul in the user registry!
[*] Forensic timeline sealed. Digital autopsy complete.

Watching cryptic log lines transform into a coherent, gripping narrative—not as fictional fantasy, but as an accurate, MITRE-mapped autopsy of a real cyber incursion—made it clear: AI doesn't just need to generate text; it can give eyes and ears to systems that were previously silent.

Prize Categories

Open Innovation Track: Privacy-first, offline digital forensics powered by open-weight AI models.
Cybersecurity & AI Agents Track: Autonomous DFIR agent with deterministic grounding, MITRE ATT&CK correlation, and automated incident response reporting.
Ghost in the Machine (Halloween Theme): Uncovering the ghost traces left in machine memory and narrating the breach via the Haunted Terminal.

Built with ❤️ for Hacktoberfest 2026. Every machine leaves a trace. Some tell a story. 👻

UdhaarOS | Hacktoberfest-Week2

Balabhadra — Sun, 18 Oct 2026 16:20:36 +0000

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

What I Built

In India and emerging markets, over 30 million Kirana stores, corner pharmacies, neighborhood grocers, and side-hustle merchants sell on informal credit (Udhaar). Selling on credit builds deep community trust and loyalty — but managing it is a daily nightmare:

Messy Paper Diaries & Lost Records: Merchants jot down daily dues on loose paper slips or torn notebooks (Khatabook). Entries get misplaced, forgotten, or disputed by customers.
Awkward & Delayed Collections: Asking neighbors and regular patrons for money feels uncomfortable. As a result, reminders are either delayed for months or worded too aggressively, damaging customer relationships.
Cash-Flow Blindspots: Store owners rarely know their exact aging breakdown (how much money is overdue past 30, 60, or 90 days), leading to bad debts and inventory stockouts.
Data Privacy Fears: Small merchants distrust proprietary cloud platforms that harvest customer phone numbers, analyze sales data for competitive lending, or lock books behind subscription paywalls.

UdhaarOS is a privacy-first, open-source credit ledger and payment intelligence system designed specifically for neighborhood retail and side-hustle entrepreneurs. It pairs a deterministic financial accounting ledger with local, open-source AI to digitize messy notes and accelerate debt recovery with zero privacy trade-offs.

Key Capabilities

⚡ AI Smart Khatabook Digitizer: Converts messy text notes, voice transcripts, and Hinglish messages (e.g. "Ramesh ji 450 udhaar diya 2 packet aata", "Sunil paid 1200 via gpay jama", "Vikram ne 250 diye via phonepe") into structured ledger entries.
🛡️ Two-Phase Human-in-the-Loop Review: AI never blindly modifies financial ledgers. Extracted entries are presented in a review table with match confidence and duplicate alerts. Merchants can edit amounts or directions before posting, and new customer profiles are provisioned automatically.
💬 Culturally Tailored Payment Reminders: Crafts polite, firm, or urgent WhatsApp and SMS reminders in Hindi / Hinglish, English, or Regional languages with pre-filled UPI payment links (wa.me) for one-click settlement.
📖 GAAP-Grade Financial Ledger: Full double-entry-inspired ledger tracking Credits (Udhaar) and Payments (Jama). All currency is computed in Paise (integers) to prevent floating-point rounding errors.
🔄 Audit-Compliant Reversals: Transactions are never deleted. Non-destructive reversal entries preserve complete auditability with documented reasons.
📊 Delinquency Aging Analytics: Categorizes dues into 0–15 Days (Current), 16–30 Days (Due Soon), 31–60 Days (Overdue), and 60+ Days (Critical) with visual 30-day debt trend charts.
🔒 100% On-Device & Offline Resilient: Integrates local Ollama LLMs with an instant deterministic rule-based fallback parser (rule-parser.service.ts). Zero financial or customer debt data ever leaves the local machine.

Demo

Live GitHub Repository: https://github.com/balabhadra3141/Hacktoberfest-Week2
Cover Image: cover.jpg (included in repository root and client/public/cover.jpg)
Local Interactive App: Runs at http://localhost:5173 with backend API at http://localhost:3001

Running the Project Locally

# 1. Clone the repository
git clone https://github.com/balabhadra3141/Hacktoberfest-Week2.git
cd Hacktoberfest-Week2

# 2. Setup and run Backend
cd server
npm install
npx prisma db push
npx tsx prisma/seed.ts
npm run dev

# 3. Setup and run Frontend (in a separate terminal)
cd ../client
npm install
npm run dev

Visit http://localhost:5173 in your browser. The application is pre-seeded with a realistic Kirana store dataset (8 customers, 25+ posted transactions, overdue debts, and active limits) ready for immediate demonstration.

Code

Repository: https://github.com/balabhadra3141/Hacktoberfest-Week2
License: MIT License

Architecture Overview

┌────────────────────────────────────────────────────────┐
│                   UdhaarOS Frontend                    │
│      Vite + React 19 + TypeScript + TailwindCSS        │
│   (Dashboard, Khata, Smart Import, WhatsApp Reminders) │
└───────────────────────────┬────────────────────────────┘
                            │ REST API (JSON)
┌───────────────────────────▼────────────────────────────┐
│                   UdhaarOS Backend                     │
│               Node.js + Express + TypeScript           │
│      Zod Validation · Financial Ledger Service         │
└─────────────┬────────────────────────────┬─────────────┘
              │                            │
   Prisma ORM + SQLite             Dual-Path AI Engine
 (Audit Trails & Reversals)   (Ollama LLM + Rule Parser)

Frontend: React 19, TypeScript, Vite, TailwindCSS, TanStack React Query, Recharts, Lucide Icons, React Hot Toast.
Backend: Node.js, Express, TypeScript, Prisma ORM, SQLite, Zod validation schemas, Dayjs.
Accounting Architecture: Paise precision (1 INR = 100 Paise), running ledger balances, non-destructive reversals with audit events.

How I Built It

1. Dual-Path Open-Source AI Architecture

UdhaarOS is designed around open-source AI with zero external dependencies:

// Dual-path extraction engine in server/src/services/ai.service.ts
export type ExtractionEngine = 'LLM' | 'RULES';

Local Open-Weight LLMs (Ollama):
- Uses local inference with open-weight models (default llama3, also tested with qwen2.5:3b and llama3.2).
- Uses strict JSON output schemas to extract structured transaction objects: customer_name, type (CREDIT vs PAYMENT), amount_paise, date, description, and confidence.
- Runtime Model Switching: Merchants can inspect all installed Ollama models and switch the active model at runtime from Store Settings → AI Engine Diagnostics, persisted directly in the database.
Deterministic Offline Fallback (rule-parser.service.ts):
- Small shops cannot afford downtime if an LLM is offline or busy.
- We engineered a specialized regex/NLP parser tuned to Hindi, Hinglish, and Indian merchant shorthand ("udhaar", "jama", "diya", "gpay", "ne diye", with automatic unit exclusions like kg, packet, ltr).
- Runs with sub-millisecond zero latency, ensuring the AI Smart Khatabook works 100% offline without any model running.

2. Two-Phase Human-in-the-Loop Review

AI should assist merchants, never blindly execute accounting entries:

Extraction Phase: The merchant pastes unorganized text or clicks sample presets.
Review & Audit Phase: Entries are mapped against the customer khata directory with confidence scores. The merchant can review, edit names, amounts, or directions, and batch-confirm with one click.

Why Does Open Innovation Matter?

Small business accounting is one of the most sensitive areas in commerce. Closed-source, cloud-dependent AI poses distinct hazards for local merchants:

Financial Data Sovereignty: A neighborhood store’s debtor list reveals personal relationships, creditworthiness, and family purchasing power. Sending this information to proprietary cloud APIs risks corporate data mining, targeted ads, or predatory lending. Open-source AI keeps 100% of the data on the merchant's device.
Zero Recurring SaaS Costs: Micro-merchants operating on 3–8% margins cannot afford monthly SaaS subscription fees or token-based API charges. Open-source open-weight models run locally for free indefinitely.
Resilience to Poor Connectivity: Wholesale markets and rural retail hubs often experience intermittent internet. A closed API fails the moment connectivity drops; open-source local inference and deterministic heuristics ensure zero downtime.
Community Adaptation: Open innovation allows developers to adapt models to regional languages (Tamil, Marathi, Bengali, Odia, Gujarati) and local trade terminologies without waiting for a proprietary API provider to support their dialect.

My Agent Session

This project was built from concept to production through an end-to-end agentic pair-programming workflow:

Domain Modeling & Precision Accounting: Designed integer Paise schemas, double-entry ledger mechanics, and non-destructive reversal workflows.
Dual-Path AI Engineering: Implemented structured Ollama local LLM integration alongside the conservative offline Hinglish rule parser.
Rapid UI/UX Iteration: Crafted a responsive desktop & mobile experience with TailwindCSS, Recharts data visualization, and cultural design touches.
Automated Browser Subagent Testing: Ran full browser subagent sessions verifying end-to-end user journeys (recording available in project artifacts).

My First User

To test UdhaarOS against real-world scenarios, I walked through the workflow with a neighborhood Kirana store owner (Sharma General Store):

The Problem: He maintained two separate dog-eared notebooks: one for daily rough scribbles (kachha khata) and one for finalized customer balances (pakka khata). Updating them took 45 minutes every evening, and customers regularly disputed 3-week-old dues.
The Reaction: He was blown away by typing "Ramesh ji 450 udhaar diya 2 packet aata" and watching it automatically map to Ramesh's account, update his credit limit bar, and generate a polite Hindi WhatsApp reminder with his store's UPI ID in two clicks.
His Verdict: "Agar ye mere phone ya dukaan ke computer pe bina internet ke chal sakta hai aur koi mera hisaab nahi dekhega, toh main diary chhodne ko tayyar hoon." ("If this runs on my shop computer without internet and nobody spies on my books, I'm ready to abandon paper diaries today.")

Prize Categories

Primary Category: Hacktoberfest Open-Source AI Challenge Week 2: "Side Hustle"
Submission Type: Individual Submission

Built with ❤️ for Hacktoberfest 2026. Empowering local merchants with open-source AI.

EcoQuest | Hacktoberfest-Week1

Balabhadra — Sun, 11 Oct 2026 14:48:00 +0000

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

What I Built

Every day, people walk through their neighbourhoods, local parks, and outdoor trails. They see overflowing bins, littered green spaces, illegal dumping, or polluted waterways — and usually do one of two things: scroll past it or feel helpless to fix it.

EcoQuest is a mobile-first, community-driven environmental action web app built for the Hacktoberfest 2026 Week 1 "Touch Grass" challenge. Its goal is simple: help people turn outdoor observations into concrete, actionable community reports in under 30 seconds.

Instead of leaving environmental stewardship to bureaucratic delay or passive social media complaints, EcoQuest provides an immediate bridge between noticing a problem and doing something about it safely.

Key Features

📱 Mobile-First Outdoor UX: Built for real-world outdoor use with quick camera capture, drag-and-drop file uploads, responsive card layouts, and touch-friendly controls.
🌿 Smart Categorisation: Classifies reports into 5 key outdoor categories:
- Litter & Debris
- Overflowing Public Bins
- Neglected Green Spaces
- Water Pollution
- Illegal Dumping
🛡️ Confidence & Honest Uncertainty Disclaimers: AI output is never treated as infallible truth. Every report displays an explicit confidence score and an uncertainty notice stating that results are automated suggestions and not independently verified.
👷 Safe Next-Action Guidance: Gives immediate, safety-first recommendations (e.g., "Wear puncture-resistant gloves," "Report hazardous bulk items to the municipal council," "Organize a small neighborhood sweep").
🔄 Community Action Workflow: A live community feed that tracks issues across clear lifecycle statuses: Open ➔ In Progress ➔ Resolved, empowering neighbors to take ownership and celebrate resolved cleanups.
🔒 Privacy-Preserving Architecture: Strict client-side EXIF stripping via HTML5 Canvas prevents accidental leakage of home coordinates or camera metadata. Location is strictly general and user-described (no invasive GPS tracking).
⚡ Zero-Barrier Sample Data Mode: Works immediately offline out of the box with zero external API keys required, making the app 100% testable and demonstrable anywhere.

Demo

Local Running App: Accessible at http://localhost:5173
Cover Art & Visuals: public/cover.jpg (included in repository)

To run the live interactive demo locally:

git clone https://github.com/balabhadra3141/Hacktoberfest-Week1.git
cd Hacktoberfest-Week1
npm install
npm run dev

Visit http://localhost:5173 and click "Load samples" to immediately populate the interactive feed, submit new camera reports, and test status transitions.

Code

Repository: https://github.com/balabhadra3141/Hacktoberfest-Week1
License: MIT License

How I Built It

EcoQuest is engineered with modern, performant, and privacy-first web tools:

Tech Stack

Frontend: React 19, TypeScript, Vite, Tailwind CSS v4, Lucide React, date-fns
Backend Proxy: Lightweight Node.js server (keeps API keys completely server-side)
Storage: Browser LocalStorage with persistent CRUD state management

Swappable AI Architecture (`AIProvider` Pattern)

A core design tenet of EcoQuest is that the UI is completely decoupled from the AI provider. In src/lib/providers.ts, all model interaction adheres to a strict contract:

export interface AIProvider {
  name: string;
  isOpenWeight: boolean;
  licenseUrl?: string;
  analyze: (payload: CreateReportPayload) => Promise<AIAnalysis>;
}

This interface enables two swappable operational modes:

Sample Provider (Default): A deterministic, zero-dependency offline engine that simulates realistic analysis without any API keys or network latency.
Vision-Language Provider (Prototype): A lightweight proxy calling Google Gemini 1.5 Flash via a backend server. The API key is stored securely in .env.local and never exposed to the client.
Pluggable Open-Weight Models: Designed specifically to be swapped out for self-hosted open-weight vision models such as LLaVA-1.6, InternVL2, or CLIP.

Why Does Open Innovation Matter?

Environmental challenges are fundamentally local, shared, and community-owned. Building environmental infrastructure on closed, proprietary AI creates severe risks:

Community Data Sovereignty: When citizens document civic issues, that data should belong to the community and local authorities — not be funneled into proprietary training datasets or held hostage behind commercial paywalls.
Auditability & Algorithmic Trust: If an AI model prioritizes or deprioritizes reports, citizens have a right to inspect the prompts and weights. With open-weight models, community members can audit the system to ensure it doesn't bias against underserved neighborhoods.
Longevity & Independence: Commercial API endpoints can be deprecated, rate-limited, or price-hiked at any moment. Open-weight models ensure that community tools will continue running decades from now on local hardware.
Zero-Telemetry Privacy: Environmental reports frequently contain background imagery of public roads or parks. Running open-weight vision models locally or on community servers means sensitive spatial imagery never leaves the municipal boundary.

Open innovation ensures that technology serves as public infrastructure, not private gatekeeping.

My Agent Session

This project was built iteratively using an advanced agentic coding pair-programming workflow:

Rapid architecture design, domain model drafting, and schema definitions.
Developing robust validation, error states, and EXIF-stripping sanitization.
Implementing a strict separation between frontend state and backend proxy inference.
Testing and validating builds with full TypeScript checking and zero warnings.

Prize Categories

Primary: Hacktoberfest Open-Source AI Challenge Week 1: "Touch Grass"
Individual Submission: Created and submitted individually.

Thank you to the Hacktoberfest and DEV teams for promoting open-source innovation and inspiring developers to get outside and touch grass!

DEV Community: Balabhadra

PhantomTrace | Hacktoberfest-Week4

What I Built

Enter PhantomTrace 👻

Demo

Key Screens & Features in Action

Code

How I Built It

1. Deterministic Grounding (Preventing AI Hallucinations)

2. Local Open-Weight Inference (Ollama + Qwen2.5 / Llama 3.2)

3. Frontend & Visualizations

Why Does Open Innovation Matter?

1. Absolute Privacy & Air-Gapped Operation

2. Auditability & Grounded Transparency

3. Zero Cost & Universal Accessibility

My Agent Session

The Spirit of It

Prize Categories

UdhaarOS | Hacktoberfest-Week2

What I Built

Key Capabilities

Demo

Running the Project Locally

Code

Architecture Overview

How I Built It

1. Dual-Path Open-Source AI Architecture

2. Two-Phase Human-in-the-Loop Review

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

EcoQuest | Hacktoberfest-Week1

What I Built

Key Features

Demo

Code

How I Built It

Tech Stack

Swappable AI Architecture (AIProvider Pattern)

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Swappable AI Architecture (`AIProvider` Pattern)