DEV Community: Divyanshi Gupta

BugBounty Hunter: Autonomous AI Forensic Bug Reproduction with Verifiable Proof Packs

Divyanshi Gupta — Sat, 24 Oct 2026 15:27:06 +0000

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

What I Built

BugBounty Hunter is an autonomous open-source AI forensic investigation platform that transforms vague defect reports into verified pytest reproduction tests, isolated execution trace evidence, and tamper-evident Proof Packs.

The Problem It Solves

Every open-source maintainer and security team knows the pain of receiving vague bug or bounty reports:

"The worker crashes when parsing certain image tags."
"The payload validator raises unhandled exceptions on edge cases."
"The API endpoint gives unexpected status codes under load."

Maintainers usually waste hours setting up clean environments, reverse-engineering the reporter's context, writing pytest boilerplate, and determining whether the claim is legitimate or just a hallucinated exploit report.

Who Gets to Be Lazier?

Open-source maintainers, bug bounty triagers, and software engineers.

Instead of spending an entire afternoon reproducing issue reports by hand, developers can drop in a GitHub repository URL and the raw issue text. BugBounty Hunter methodically inspects the AST, constructs hypotheses, and synthesizes a verified test inside an isolated sandbox—leaving maintainers with a complete, reproducible Proof Pack with a single click.

Demo

Live Frontend: https://bugbounty-hunter.vercel.app
API Documentation: https://bugbounty-api.onrender.com/docs
Sample Verified Target: Comes with built-in fixture repository (fixtures/sample-buggy-repo) showcasing automated reproduction of Issue #42 with real execution traces and passing forensic reports.

Code

divyanshigupta786 / Bugbounty-hunter

BugBounty Hunter

Every bug has a story. Every claim needs proof.

BugBounty Hunter is an open-source AI developer tooling platform that turns vague defect reports into reproducible pytest tests, isolated container execution evidence, and portable, verifiable Proof Packs.

🎯 The Core Philosophy: Investigation, Not Hallucination

Developers frequently receive incomplete reports like:

"The worker crashes when parsing image tags."
"The validator raises unhandled errors on certain payloads."
"This API endpoint returns wrong results on edge cases."

Rather than having an LLM guess or hallucinate answers in a chat box, BugBounty Hunter treats defect reproduction as a forensic engineering discipline:

The Reproduction Ladder: Escalates from baseline checks to AST inspection, candidate synthesis, and container execution.
Honest Verdicts: Strictly assigns REPRODUCED, NOT_REPRODUCED, or INCONCLUSIVE. A broken setup or timeout is never reported as bug absence.
Evidence-First Proof Pack: Produces a portable, reproducible archive with the exact test source code…

View on GitHub

Full source code repository: https://github.com/divyanshigupta786/Bugbounty-hunter

How I Built It

BugBounty Hunter is built specifically around the philosophy of "Slow and Steady" investigation rather than fast, hallucinated one-shot answers.

Architecture Overview

Next.js 14 Frontend: Interactive dashboard with Three.js visualization, real-time investigation timeline (Reproduction Ladder), interactive test code viewer, and Proof Pack download inspector.
FastAPI Async Engine: Python backend implementing a bounded state machine that guards the forensic workflow.
Dual Sandbox Isolation: Test candidates execute either in containerized environments (--network none) or confined subprocesses with purged credentials, strict timeouts (30s), memory limits (512MB), and automated secret redaction.

Open-Source AI Stack

Open-Weight Code Models via Ollama: Powered locally by qwen2.5-coder:7b for precise code AST understanding and targeted hypothesis formulation.
Cloud Acceleration: Optional Google Gemini integration (gemini-2.5-flash) for instant hypothesis synthesis while retaining full offline, local capabilities.
The 4-Step Reproduction Ladder:
- Step 1: Baseline Verification: Validates repository test suite hygiene prior to investigation.
- Step 2: AST & Target Discovery: Pinpoints suspect functions and error signatures.
- Step 3: Candidate Synthesis: Generates isolated pytest reproduction scripts.
- Step 4: Disposable Execution: Runs candidate code in a network-disabled sandbox and captures exit codes, sanitized tracebacks, and stdout.
Honest Verdicts: The engine strictly assigns REPRODUCED, NOT_REPRODUCED, or INCONCLUSIVE. A failed environment setup or timeout is never mistaken for a bug's absence.

Why Does Open Innovation Matter?

Open-source AI and open innovation were essential to making BugBounty Hunter possible:

Security & Air-Gapped Codebases: Companies and security bounty hunters cannot send confidential, unpatched 0-day vulnerability reports or proprietary codebases to black-box commercial APIs. Running open-weight models (like qwen2.5-coder) locally via Ollama guarantees that sensitive bug reports and source code never leave the developer's machine.
Deterministic Reproducibility: Closed APIs change their weights and system prompts unannounced, breaking agent determinism. Open-weight models ensure reproducible forensic pipelines where a bug investigation conducted today produces verifiable results months later.
Inspectable Toolchains: True security tooling requires an auditable chain of custody. Closed models cannot be verified down to the container execution boundary—open innovation allows every step from AST parsing to unprivileged sandbox execution to be transparent and trustworthy.

The Lazy Payoff

Hours Saved per Issue: Triage time drops from 45–90 minutes of manual environment setup, script writing, and verification down to under 2 minutes of automated background execution.
Zero Boilerplate: Generates ready-to-merge test_reproduction.py and replay.sh scripts directly attached to the output Proof Pack.
Noise Elimination: Automatically weeds out bogus or hallucinated bug reports without human intervention, sparing maintainers burnout from low-effort submissions.

Prize Categories

Primary: Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
Categories:
- Best Use of Open-Source AI / Open-Weight Models (Ollama & Qwen 2.5 Coder)
- Developer Tools & Productivity

BatchTrace Agent — AI-Powered Food Traceability & Incident Intelligence Platform

Divyanshi Gupta — Sun, 18 Oct 2026 03:45:09 +0000

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

BatchTrace Agent — AI-Powered Food Traceability & Incident Intelligence Platform

"Every batch has a story. Find it instantly."

What I Built

The Problem

Small and mid-sized food manufacturers, commercial bakeries, packaged-food producers, and craft processors (20–250 employees) face a massive operational nightmare: their supply chain records live in disconnected silos.

Supplier invoices arrive as scanned PDFs.
Receiving dock manifests sit in paper binders.
Batch production travelers and mixing records are logged in Excel sheets.
Customer dispatches and bills of lading are stored in carrier portals.

When an ingredient supplier issues an urgent quality alert (e.g., "Supplier lot L-204 of Organic Rolled Oats has elevated DON mycotoxins"), quality assurance (QA) teams spend 48 to 72 hours in panic mode digging through spreadsheets to answer three critical questions:

Which manufacturing batches consumed this lot?
Which finished products and packaging runs contain it?
Which customer orders, distribution centers, and grocery retailers received affected shipments?

A delay in answering these questions can lead to catastrophic public recalls, FDA/USDA warning letters, retail fines, and severe brand damage.

The Solution: BatchTrace Agent

BatchTrace Agent is a full-stack, AI-powered industrial intelligence platform that connects disconnected food manufacturing documents into a deterministic traceability graph, reconciles mass balances, and uses an open-weight AI copilot to guide investigations with 100% grounded evidence.

Who Would Pay for It?

Small to Medium Food & Beverage Producers: Commercial bakeries, snack producers, granola & cereal brands, and dairy processors.
Co-packers & Contract Manufacturers: Facilities managing dozens of client SKUs requiring rapid audit-readiness.
Food Safety & SQF/BRCGS Compliance Consultants: Quality managers who need instant mock-recall compliance reports for annual audits.
Business Model: SaaS pricing tiered from $199/month (Starter: 5,000 batches/year) to $799/month (Enterprise: multi-facility, live automated document ingestion, and compliance audit exports).

Demo

Live Web Application: https://batchtrace-dev-challenge.vercel.app
GitHub Repository: https://github.com/divyanshigupta786/Batchtrace-dev-challenge-

Live Platform Features You Can Test:

TraceSphere 3D Interactive WebGL Network: A procedural 3D supply chain storytelling environment built with Three.js (@react-three/fiber & @react-three/drei) with camera controls and hover inspection.
Interactive Live Trace Simulator: Switch between lots (L-204, L-205, L-206) to watch the forward trace pipeline animate in real-time, detecting the synthetic 50 kg mass balance discrepancy.
2D Operational Traceability Explorer (/app/trace): Execute forward traces from ingredient lots and backward traces from customer orders (ORD-101) to primary agricultural suppliers.
Side-by-Side Document Review (/app/documents): Raw invoice and receiving logs previewed side-by-side with coordinate-grounded field extraction (page, row, character offsets) and draft/approve/reject actions.
Open-Weight AI Investigation Copilot (/app/agent): Query the agent with natural language; inspect live step-by-step tool execution traces (get_ingredient_lot, trace_ingredient_lot, check_quantity_discrepancies, get_source_evidence); view evidence chips; and approve proposed human sign-off actions.
Printable Audit Dossier (/app/incidents/INC-2026-001): Audit-ready printable layout (window.print()) with complete provenance citations.

Code

divyanshigupta786 / Batchtrace-dev-challenge-

BatchTrace Agent — AI-Powered Food Traceability & Incident Intelligence Platform

"Every batch has a story. Find it instantly."

Explainable, evidence-grounded food supply chain traceability and batch investigation platform designed for food manufacturers, bakeries, and packaged-food producers.

1. System Overview & Problem Statement

When an ingredient supplier issues an alert (e.g. "Supplier lot L-204 has elevated DON mycotoxin levels"), quality assurance and plant operations teams typically spend hours or days digging through disconnected spreadsheets, PDF invoices, paper traveler sheets, and carrier bills of lading to answer three critical questions:

Which production batches consumed this ingredient lot?
Which finished-product lots and packaging runs were generated?
Which customer orders, distribution centers, and retailers received affected goods?

BatchTrace Agent solves this through a dual-engine architecture:

Deterministic Relational Engine: Serves as the immutable single source of truth. Traverses the graph, enforces mass balances, isolates quantity discrepancies, and computes certainty ratings (CONFIRMED…

View on GitHub

Repository Highlights:

Next.js 16 Full-Stack: App Router, React 19, TypeScript strict mode, Tailwind CSS.
Trace Engine: Pure deterministic TypeScript engine (src/lib/engine/traceabilityEngine.ts) and standalone Python engine (backend/engine.py).
Database Schema: 17 normalized relational tables in supabase/migrations/20261017000000_batchtrace_schema.sql with Row Level Security (RLS) policies and B-tree indexes.
OpenAPI Microservice: Python FastAPI backend with Pydantic v2 schemas and unit tests.
Automated Test Suite: 5 test suites (22 assertions) running with npm test.

How I Built It

1. Open-Source AI Architecture

At the core of the investigation workspace is the Qwen2.5/Qwen3 open-weight model family, run via Ollama for private, on-premise inference and configurable for hosted endpoints.

Rather than treating the LLM as an unconstrained chatbot that might fabricate customer orders or lot codes, BatchTrace employs a strictly controlled tool-calling harness:

The AI model operates within a finite set of typed, server-side tools:
- search_records
- get_ingredient_lot
- trace_ingredient_lot
- trace_finished_lot_backward
- check_quantity_discrepancies
- get_source_evidence
- prepare_incident_report
Zero Hallucination Guarantee: The relational PostgreSQL database and deterministic traversal engine are the single source of truth. The AI model has no direct SQL write access.
Evidence-Backed Chips: Every factual claim generated in the agent's response is tagged with an evidence reference (record ID, document citation, row number).
Graceful Deterministic Fallback: If the local Ollama instance or external inference endpoint is offline, the system seamlessly enters Deterministic Fallback Mode, ensuring 100% uptime for plant operators.

2. Dual-Engine Traceability & Mass Balance Reconciliation

Forward Traversal: Resolves: Supplier → Ingredient Lot (L-204) → Batches (PB-031, PB-032) → Finished Lots (FP-101, FP-102) → Retail Orders (ORD-101 to ORD-107).
Backward Traversal: Resolves from any downstream customer delivery back to the master production batch, all consumed raw ingredients, and agricultural growers.
Mass Balance Audit: Automatically compares received inventory against recorded production consumption. For example, Lot L-204 received 1,200 kg, but production logged 800 kg in PB-031 and 450 kg in PB-032 (1,250 kg total), immediately flagging an intentional -50 kg discrepancy.
Certainty System: Explicitly labels every relationship as CONFIRMED (backed by approved signed traveler sheets), POSSIBLE (suggested by matching rules but pending QA review), or UNKNOWN (missing records).

3. Frontend & Visual Design System

Curated Industrial Palette: Forest Green (#173D32), Deep Forest (#102C25), Warm Ivory (#F7F6F0), Soft Sage (#DCE8DF), Signal Amber (#E9A23B), and Risk Red (#B94343).
Motion & Scrolling: Lenis momentum wheel scrolling paired with Anime.js v4 procedural SVG supply chain path drawing and Framer Motion micro-interactions.
TraceSphere 3D Experience: Restrained procedural WebGL node network using Three.js and @react-three/drei with camera-facing Billboards and SDF Text.

Why Does Open Innovation Matter?

Food supply chain and batch execution data represents some of the most confidential commercial intellectual property a manufacturer possesses:

Proprietary recipe ratios and ingredient formulations.
Supplier pricing, volume discounts, and vendor identities.
Yield efficiency metrics, scrap rates, and operating margins.
Customer delivery volumes, retailer distribution networks, and packaging agreements.

Why Closed APIs Fail This Use Case:

Data Sovereignty & Trade Secrets: Mid-sized food manufacturers cannot stream proprietary formulation logs and internal supplier invoices to closed, third-party proprietary API clouds where terms of service permit telemetry logging or training.
Air-Gapped & Edge Plant Readiness: Food processing facilities and grain elevators are often located in rural areas with intermittent connectivity. Open-weight models like Qwen running on local hardware via Ollama allow food safety software to run entirely on-premise without internet dependency.
Auditability & Explainability: Regulatory bodies (FDA, CFIA, EFSA) do not accept "the cloud AI said so" during a product recall audit. Open-source models paired with deterministic relational constraints provide verifiable, reproducible, and legally defensible recall dossiers.

Open innovation makes it possible to build enterprise-grade intelligence that respects user ownership, guarantees privacy, and delivers reliable decision-support software.

My Agent Session

This complete hackathon MVP was designed, planned, developed, tested, and deployed with Google Antigravity:

Autonomous generation of the 17-table PostgreSQL Supabase schema with Row-Level Security.
Development of the dual TypeScript and Python deterministic traceability engines.
Construction of the React 19 / Next.js 16 frontend with Three.js WebGL canvas and Lenis momentum scrolling.
Implementation of the controlled open-weight model adapter with bounded tool calling.
Automated end-to-end verification passing all 5 test suites (22 assertions) with npm test and python backend/test_backend.py.

My First User

Persona: Elena Rostova, Quality Assurance Manager at Meadow Pantry Products Inc.

We ran an end-to-end simulation using the synthetic dataset for Meadow Pantry Products Inc., a mid-sized organic granola and snack producer.

The Test Scenario:
Elena received a formal notification from Greenfield Ingredients Co. flagging Lot L-204 of Organic Rolled Oats due to an elevated DON mycotoxin advisory.

Elena's Feedback:

"Usually, when an alert like this arrives at 4:30 PM on a Friday, our QA team has to stay until midnight pulling physical batch folders, matching PO numbers in QuickBooks, and calling cold-storage logistics to see where pallets ended up. With BatchTrace, we pasted the lot code, and within 3 seconds it showed both granola batches (PB-031 and PB-032), flagged the 50 kg over-consumption, identified the 5 affected grocery orders (Whole Foods, FreshDirect, Trader Joe's), and drafted an incident report with exact document references. This transforms a multi-day panic into a 5-minute verified response."

Prize Categories

Best Open-Source AI Project (leveraging Qwen open-weight models via Ollama with controlled tool-calling and zero-hallucination deterministic grounding)
Best Side Hustle / Commercial Viability (high-value, B2B compliance-critical SaaS targeted at small-to-medium food manufacturers)
Best Developer Experience / Documentation (full OpenAPI specs, 17-table relational migration, complete test suites, and 1-click deployment blueprints)This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

Mundane — Your City Is More Interesting Than You Think (Offline Urban Field Journal)

Divyanshi Gupta — Mon, 12 Oct 2026 06:57:57 +0000

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

What I Built

Tagline: “Your city is more interesting than you think.”

Most modern AI applications do the exact opposite of getting you outside: they trap you in infinite chat windows, summarize experiences you never had, and replace genuine human curiosity with pre-digested answers.

I built Mundane as an antidote: a tactile, editorial urban field journal inspired by documentary photography and independent print zines. It invites you to step outside, slow down, put your phone in your pocket, and record the subtle, overlooked textures, geometries, and artifacts of your everyday neighborhood.

The Defining Principle: Blind First, AI Second

Mundane is governed by a strict philosophy: AI never interprets before you observe.

Observe: Pick an observational quest (e.g., Pattern Hunt, Urban Archaeology, Design Detective, Light and Shadow, or Unexpected Geometry).
Record: Register your physical observations in your own unfiltered words. Attach an optional photo. Everything is stored locally on-device in IndexedDB.
Reflect (Optional & Grounded): Only after your observation is saved can you request an AI reflection. The model reflects strictly on what you documented, synthesizes your field note, asks one thought-provoking follow-up question, and recommends your next urban walk.

The Mundane Field Folio Studio (Zero-Screen Immersion)

To achieve true digital detox, Mundane features the Field Folio Studio:

8-Page Pocket Mini-Zine: An algorithmic imposition engine formats an entire 8-page observation booklet onto a single sheet of A4 paper.
No Glue Required: Three simple creases and one center slit transform the printed sheet into an authentic pocket zine complete with cover art, observation checklist, sketching frame, and notes log.
Single-Page Worksheet: Printable A4 field notes sheet for clipboards.
3D Digital Folio Viewer: An interactive book-opening simulator featuring authentic paper folds, spine gutter shading, and tactile page-turning controls.

Demo

Live Application: https://dev-challenge-2-ten.vercel.app
API & Backend: https://dev-challenge-2-production.up.railway.app
GitHub Repository: https://github.com/divyanshigupta786/dev-challenge-2

Highlights to Try Out:

The Hero Carousel (/): Explore the 4 rotating photographic scenarios with hover-pause and manual < > slides. Tap the hand-drawn observation circle to discover hidden urban clues.
The 3D Booklet Preview (/ & /folio): Toggle the "Fold Booklet / Open Booklet" animation to see the pocket zine open flat in 3D perspective.
Printable Folio (/folio): Click "Print Booklet (A4)" to trigger the pre-configured print stylesheet.
Local Journal (/journal): Browse, search, and edit past entries with zero internet connection.

Code

divyanshigupta786 / dev-challenge-2

Mundane

Your city is more interesting than you think. Built for Hacktoberfest Dev Challenge 2: "Touch Grass"

Mundane is a local-first AI field journal designed to help you slow down, explore the overlooked corners of your everyday city, and register physical observations before consulting artificial intelligence.

🌿 Core Tenets

Blind First, AI Second: You must look and write first. The AI reflection stays locked until your own field observation is recorded.
Local-First & Private: Observations and photos remain stored on your machine in IndexedDB. No forced cloud accounts, tracking, or telemetry.
Honest AI: Clear real-time status reporting against your local Ollama runtime (gemma3:4b). No fake responses or mocked status badges.
Urban Field Notebook Aesthetic: Tailored typography (Newsreader serif headings, DM Sans body) with concrete paper tones and natural mineral accents (oxide, weathered stone, dust, patina).

🧭 Screen Tour

Today: Daily rotating observation quest…

View on GitHub

Architectural Stack

Frontend: React 19, TypeScript, Vite, Tailwind CSS, Lucide Icons, motion/react (Framer Motion).
Local Storage Engine: Dexie.js (IndexedDB) for client-side privacy and offline persistence.
Backend Service: FastAPI, Pydantic v2 Settings, HTTPX, Uvicorn, Docker.
AI Runtimes:
- Local Offline Inference: Ollama integration (gemma3:4b / llama3.2:3b).
- Fast Cloud Inference: Groq open-weight provider (qwen/qwen3.8-27b).
Deployment: Containerized on Railway (backend) and Vercel CDN (frontend).

How I Built It

1. Open-Weight AI Architecture

Mundane is built around open-weight models:

Local Offline Inference with Ollama: When walking through parks or subways with no reception, users can run open-weight models completely offline on http://localhost:11434.
High-Speed Cloud Inference with Groq: In the cloud deployment, Mundane connects to open-weight models like qwen/qwen3.8-27b via Groq, delivering sub-second latency with zero cold-start delay.

2. Strict Grounding Prompt Engineering

Commercial chatbots often hallucinate what you "probably saw". Mundane uses an isolated prompt engine (prompt_service.py) with strict negative constraints:

Must reflect only on details explicitly mentioned in the user's field note.
Never flatters or praises artificially.
Concludes with exactly one grounded question that challenges the user to return to the physical location and look closer.

3. Mathematical Mini-Zine Imposition

Fitting 8 pages onto a single A4 landscape sheet requires precise geometric inversion:

The top 4 panels (Pages 1, 8, 7, 6) are rotated 180 degrees so they face right-side-up once the paper is folded horizontally.
Bottom panels (Pages 2, 3, 4, 5) remain upright.
Fold and cut guides are calibrated to ISO 216 dimensions (210mm × 297mm).

4. Local-First Privacy Sovereignty

All entries, timestamps, and camera photo blobs reside in browser IndexedDB. Zero tracking cookies, zero external analytics, and zero required account sign-ups.

Why Does Open Innovation Matter?

Open innovation is fundamental to why this project works:

Human Sovereignty & Privacy: Personal thoughts recorded during solitary walks should never be monetized, profiled, or ingested by closed AI corporations to train ad-targeting models. Open innovation ensures that local-first, on-device computing remains viable.
True Digital Detox & Off-Grid Independence: Closed AI APIs demand constant connectivity. Open-weight models empower you to disconnect your Wi-Fi, turn off cellular data, step into nature or quiet city alleys, and still enjoy an intelligent companion that respects your focus.
Grounded Reflection Over Engagement Optimization: Proprietary consumer AI models are optimized to keep users chatting for as long as possible. Open-source models allowed us to craft a focused system whose primary mission is to get you off the screen and back into the world.

My Agent Session

This application was engineered using agentic AI pair programming:

Implemented and verified the mathematical Field Folio booklet imposition.
Polished the responsive editorial design system (Instrument Serif, Newsreader, Caveat).
Containerized the FastAPI backend with multi-stage Docker and verified 10/10 passing unit tests.

Prize Categories

Touch Grass (Primary) — Built entirely to break screen fatigue, inspire real-world urban exploration, and enable zero-screen observations via printable 8-page pocket booklets.
Open Innovation — Centered on open-weight inference (Ollama local inference and Groq open-weight models), transparent grounding prompts, and local-first data architecture.

Community Discussion & Feedback 💬

I wrote Mundane because I found myself constantly looking down at my phone during walks instead of noticing the incredible architectural history, moss patterns, and transient light in my own city.

Have you ever noticed a tiny detail on your daily commute that you had walked past for years?
Would you print out a pocket zine like the Field Folio, or do you prefer logging notes digitally?

Drop your thoughts and questions in the comments below — I would love to hear how you explore your city! 🌿

Mundane — Your City Is More Interesting Than You Think (Offline Urban Field Journal)

Divyanshi Gupta — Mon, 12 Oct 2026 06:48:43 +0000

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

What I Built

Tagline: “Your city is more interesting than you think.”

The Defining Principle: Blind First, AI Second

Mundane is governed by a strict philosophy: AI never interprets before you observe.

Observe: Pick an observational quest (e.g., Pattern Hunt, Urban Archaeology, Design Detective, Light and Shadow, or Unexpected Geometry).
Record: Register your physical observations in your own unfiltered words. Attach an optional photo. Everything is stored locally on-device in IndexedDB.
Reflect (Optional & Grounded): Only after your observation is saved can you request an AI reflection. The model reflects strictly on what you documented, synthesizes your field note, asks one thought-provoking follow-up question, and recommends your next urban walk.

The Mundane Field Folio Studio (Zero-Screen Immersion)

To achieve true digital detox, Mundane features the Field Folio Studio:

8-Page Pocket Mini-Zine: An algorithmic imposition engine formats an entire 8-page observation booklet onto a single sheet of A4 paper.
No Glue Required: Three simple creases and one center slit transform the printed sheet into an authentic pocket zine complete with cover art, observation checklist, sketching frame, and notes log.
Single-Page Worksheet: Printable A4 field notes sheet for clipboards.
3D Digital Folio Viewer: An interactive book-opening simulator featuring authentic paper folds, spine gutter shading, and tactile page-turning controls.

Demo

Live Application: https://dev-challenge-2-ten.vercel.app
API & Backend: https://dev-challenge-2-production.up.railway.app
GitHub Repository: https://github.com/divyanshigupta786/dev-challenge-2

Highlights to Try Out:

The Hero Carousel (/): Explore the 4 rotating photographic scenarios with hover-pause and manual < > slides. Tap the hand-drawn observation circle to discover hidden urban clues.
The 3D Booklet Preview (/ & /folio): Toggle the "Fold Booklet / Open Booklet" animation to see the pocket zine open flat in 3D perspective.
Printable Folio (/folio): Click "Print Booklet (A4)" to trigger the pre-configured print stylesheet.
Local Journal (/journal): Browse, search, and edit past entries with zero internet connection.

Code

divyanshigupta786 / dev-challenge-2

Mundane

Your city is more interesting than you think. Built for Hacktoberfest Dev Challenge 2: "Touch Grass"

🌿 Core Tenets

Blind First, AI Second: You must look and write first. The AI reflection stays locked until your own field observation is recorded.
Local-First & Private: Observations and photos remain stored on your machine in IndexedDB. No forced cloud accounts, tracking, or telemetry.
Honest AI: Clear real-time status reporting against your local Ollama runtime (gemma3:4b). No fake responses or mocked status badges.
Urban Field Notebook Aesthetic: Tailored typography (Newsreader serif headings, DM Sans body) with concrete paper tones and natural mineral accents (oxide, weathered stone, dust, patina).

🧭 Screen Tour

Today: Daily rotating observation quest…

View on GitHub

Architectural Stack

Frontend: React 19, TypeScript, Vite, Tailwind CSS, Lucide Icons, motion/react (Framer Motion).
Local Storage Engine: Dexie.js (IndexedDB) for client-side privacy and offline persistence.
Backend Service: FastAPI, Pydantic v2 Settings, HTTPX, Uvicorn, Docker.
AI Runtimes:
- Local Offline Inference: Ollama integration (gemma3:4b / llama3.2:3b).
- Fast Cloud Inference: Groq open-weight provider (qwen/qwen3.8-27b).
Deployment: Containerized on Railway (backend) and Vercel CDN (frontend).

How I Built It

1. Open-Weight AI Architecture

Mundane is built around open-weight models:

Local Offline Inference with Ollama: When walking through parks or subways with no reception, users can run open-weight models completely offline on http://localhost:11434.
High-Speed Cloud Inference with Groq: In the cloud deployment, Mundane connects to open-weight models like qwen/qwen3.8-27b via Groq, delivering sub-second latency with zero cold-start delay.

2. Strict Grounding Prompt Engineering

Commercial chatbots often hallucinate what you "probably saw". Mundane uses an isolated prompt engine (prompt_service.py) with strict negative constraints:

Must reflect only on details explicitly mentioned in the user's field note.
Never flatters or praises artificially.
Concludes with exactly one grounded question that challenges the user to return to the physical location and look closer.

3. Mathematical Mini-Zine Imposition

Fitting 8 pages onto a single A4 landscape sheet requires precise geometric inversion:

The top 4 panels (Pages 1, 8, 7, 6) are rotated 180 degrees so they face right-side-up once the paper is folded horizontally.
Bottom panels (Pages 2, 3, 4, 5) remain upright.
Fold and cut guides are calibrated to ISO 216 dimensions (210mm × 297mm).

4. Local-First Privacy Sovereignty

All entries, timestamps, and camera photo blobs reside in browser IndexedDB. Zero tracking cookies, zero external analytics, and zero required account sign-ups.

Why Does Open Innovation Matter?

Open innovation is fundamental to why this project works:

Human Sovereignty & Privacy: Personal thoughts recorded during solitary walks should never be monetized, profiled, or ingested by closed AI corporations to train ad-targeting models. Open innovation ensures that local-first, on-device computing remains viable.
True Digital Detox & Off-Grid Independence: Closed AI APIs demand constant connectivity. Open-weight models empower you to disconnect your Wi-Fi, turn off cellular data, step into nature or quiet city alleys, and still enjoy an intelligent companion that respects your focus.
Grounded Reflection Over Engagement Optimization: Proprietary consumer AI models are optimized to keep users chatting for as long as possible. Open-source models allowed us to craft a focused system whose primary mission is to get you off the screen and back into the world.

My Agent Session

This application was engineered using agentic AI pair programming:

Implemented and verified the mathematical Field Folio booklet imposition.
Polished the responsive editorial design system (Instrument Serif, Newsreader, Caveat).
Containerized the FastAPI backend with multi-stage Docker and verified 10/10 passing unit tests.

Prize Categories

Touch Grass (Primary) — Built entirely to break screen fatigue, inspire real-world urban exploration, and enable zero-screen observations via printable 8-page pocket booklets.
Open Innovation — Centered on open-weight inference (Ollama local inference and Groq open-weight models), transparent grounding prompts, and local-first data architecture.

Community Discussion & Feedback 💬

I wrote Mundane because I found myself constantly looking down at my phone during walks instead of noticing the incredible architectural history, moss patterns, and transient light in my own city.

Have you ever noticed a tiny detail on your daily commute that you had walked past for years?
Would you print out a pocket zine like the Field Folio, or do you prefer logging notes digitally?

Drop your thoughts and questions in the comments below — I would love to hear how you explore your city! 🌿

AcadFlow — I Built an AI Academic Operating System for My Friend Who Drowns in Deadlines Every Semester

Divyanshi Gupta — Sun, 04 Oct 2026 14:58:54 +0000

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

What I Built

My closest friend, Priya, is a third-year Computer Science student. Every semester, she drowns in the same chaos — missed assignment notifications buried in WhatsApp groups, half-remembered quiz dates, and study plans that collapse the moment a professor reschedules a lab.

She does not lack information. She has too much, scattered across five apps, three portals, and a camera roll full of screenshots.

I built AcadFlow — an AI Academic Operating System that solves exactly this problem. Instead of another generic planner or a ChatGPT wrapper that confidently invents fake deadlines, AcadFlow is a deterministic planning engine with open-source AI assistance.

What it does:

Academic Inbox: Paste raw WhatsApp announcements, upload syllabus PDFs, or voice-dictate assignment requirements. Open-source LLMs extract structured tasks, courses, and deadlines.
Zero-Hallucination Priority Engine: Every task gets a mathematically computed priority score (RED / ORANGE / YELLOW / GREEN). If a deadline is not explicitly stated, it stays null — the system never invents one.
Daily Planner: Generates focus blocks within a customizable study-hour budget, with cognitive breaks.
Adaptive Replanning (Signature Feature): When Priya reports "I only finished 45 minutes of DBMS instead of 90", AcadFlow recalculates the entire schedule — safely shifting low-priority tasks to tomorrow while preserving imminent exam revision. It explains its trade-offs in plain language.
Knowledge Base (RAG): Upload lecture notes and study guides. Ask questions grounded in actual indexed documents with source citations.
Workload Analytics: Tracks completion rates and learns that Priya consistently takes 30% longer on programming assignments, automatically adjusting future estimates.
Goals & Projects: Long-term milestone tracking and collaborative project management with AI blocker warnings.

Demo

Live Frontend (Vercel):

https://acadflow-devchallenge1.vercel.app

GitHub Pages (Landing Showcase):

https://divyanshigupta786.github.io/Acadflow-devchallenge1/

Try the Pre-loaded Demo Student Account:

Email: demo@acadflow.dev
Password: demo123

Pre-loaded with 5 real CS courses, 12 realistic tasks, an active daily schedule, indexed study documents, and a collaborative AI project — ready to explore immediately.

Code

divyanshigupta786 / Acadflow-devchallenge1

AcadFlow — AI-Powered Academic Operating System

From academic chaos to clarity.

AcadFlow is a production-quality, open-source AI academic productivity and planning platform. Designed for college and university students managing multiple courses, assignments, exams, projects, and extracurriculars, AcadFlow transforms fragmented academic information into an adaptive, personalized action plan.

1. Product Philosophy: Not Another Chatbot

Students do not have a lack of academic information; they have an academic information overload problem. Academic information is scattered across:

WhatsApp messages
Google Classroom
College ERP & Portals
Emails & PDFs
Screenshots & handwritten notes
Project chat threads

AcadFlow replaces manual planning with an academic decision and planning engine powered by open-source AI.

The Core Loop

INPUT ──► UNDERSTAND ──► PRIORITIZE ──► PLAN ──► EXECUTE ──► MONITOR ──► REPLAN

2. Signature Feature: Adaptive Replanning

When a student reports:

"I only completed 45 minutes of DBMS." or "I lost 2 hours today."

AcadFlow does not simply…

View on GitHub

Project Structure

Acadflow-devchallenge1/
├── frontend/                 # Next.js 14 (App Router) + TypeScript + Tailwind
│   └── src/
│       ├── app/              # 17 pages: dashboard, tasks, inbox, courses, analytics...
│       ├── components/       # Sidebar, Navbar, ThemeToggle, Footer...
│       └── lib/              # api.ts, types.ts, utils.ts
├── backend/                  # Python 3.11 + FastAPI + SQLAlchemy
│   └── app/
│       ├── main.py           # Application entry point
│       ├── config.py         # Pydantic Settings + Supabase config
│       └── routers/          # Auth, tasks, courses, inbox, planner, AI endpoints
│           └── ai.py         # Ollama LLM + deterministic fallback + RAG
├── backend/tests/            # 13 test cases (pytest)
├── index.html                # Standalone self-contained landing page showcase
├── docker-compose.yml        # One-command stack: FastAPI + Next.js + PostgreSQL + Ollama
└── .github/workflows/        # CI + GitHub Pages automated deployment

How I Built It

Open-Source AI Architecture

AcadFlow is built around a dual-intelligence architecture that decouples AI assistance from deterministic business logic:

1. Local LLM Inference via Ollama

# backend/app/routers/ai.py
response = requests.post(
    f"{settings.OLLAMA_BASE_URL}/api/generate",
    json={
        "model": settings.OLLAMA_MODEL,  # qwen2.5:7b, llama3.2, mistral, gemma2
        "prompt": extraction_prompt,
        "stream": False,
    },
    timeout=60,
)

Supported models: Qwen 2.5:7b, Llama 3.2, Mistral 7B, Gemma 2, plus any OpenAI-compatible local endpoint.

2. Anti-Hallucination Rules (Hardcoded)

# The LLM is explicitly instructed:
# "If you are not 100% certain of the deadline from the text, set deadline to null."
# "Never invent, estimate, or assume deadlines."
# Inferred estimates are tagged ai_estimate=True and shown visually in the UI.

3. Deterministic Priority Engine (Zero LLM Involvement)

Priority Score = (Urgency + Importance + Workload + Dependency Risk + Exam Proximity)
                 ─────────────────────────────────────────────────────────────────────
                                   Completion Progress Factor

RED    >= 75  →  Imminent deadline (<24h), exam, or overdue
ORANGE 50-74  →  Due within 48h or blocking teammates
YELLOW 25-49  →  Standard runway assignments
GREEN  < 25   →  Extended deadlines or completed

4. Adaptive Replanning Engine

def replan(student_report: str, active_tasks: list, today_budget_minutes: int):
    # 1. Parse what was completed vs planned
    # 2. Recalculate remaining workload per task
    # 3. Identify tasks safely shiftable (low priority, distant deadline)
    # 4. Preserve imminent exam revision and high-stakes deadlines
    # 5. Return new schedule + plain-language trade-off explanation

5. Knowledge Base RAG

Documents are chunked, embedded with BGE Embeddings, stored in pgvector.
Queries retrieve top-k chunks by cosine similarity.
Every AI answer includes source citations linking back to the original document.

Tech Stack

Layer	Technology
Frontend	Next.js 14 (App Router), TypeScript, Tailwind CSS, Lucide Icons
Backend	Python 3.11, FastAPI, Pydantic v2, SQLAlchemy 2.0, Uvicorn
Database	SQLite (local dev) / PostgreSQL + pgvector / Supabase
AI Inference	Ollama — Qwen 2.5, Llama 3.2, Mistral, Gemma 2 + Deterministic Fallback
Embeddings & RAG	BGE Embeddings + cosine similarity via pgvector
UI Design	Cormorant Garamond + Poppins, cream/teal palette, dark/light theme
Containerization	Docker + Docker Compose
Deployment	Vercel (frontend) + GitHub Pages + GitHub Actions CI/CD
Tests	Pytest — 13 test cases

Why Does Open Innovation Matter?

1. Student Privacy Cannot Be Negotiated

A proprietary closed API like GPT-4 would mean sending every student's assignment text, course names, exam schedules, and study patterns to a third-party commercial server. With Ollama, no academic data ever leaves Priya's laptop.

2. Zero Cost = Universal Access

University students do not have budgets for $20/month API subscriptions. With open-weight models (Llama, Qwen, Gemma — all free, all local), the entire system runs on a consumer laptop with 8–16GB RAM. A closed API would price out the exact students who need it most — those in emerging economies without premium subscription budgets.

3. Deterministic Reliability Over Probabilistic Drift

The most critical feature — the Priority Engine and Adaptive Replanning — uses zero AI. It runs deterministic math. This architectural decision was only possible because open-source models forced intentionality: use AI only where it adds value, hardcode everything where correctness is non-negotiable. Proprietary APIs tempt developers to "just ask GPT what priority this task should be" — leading to hallucinated urgency and fabricated deadlines. Open-source models prevented this anti-pattern.

4. Community Auditability for Academic Tools

Any tool that affects a student's study plan and exam preparation must be transparent. With open-source models and a fully open-source codebase, any student, professor, or researcher can audit exactly how AcadFlow makes its recommendations. Closed APIs are black boxes. Open innovation means accountability.

My Agent Session

This project was built with Google Antigravity (AGY) AI coding assistant. The session covered:

Designing the deterministic priority scoring system and anti-hallucination pipeline
Building the Adaptive Replanning Engine
Full Next.js 14 App Router frontend with 17 pages
Real-time dark/light theme toggle with localStorage persistence
Supabase + PostgreSQL backend integration
GitHub Actions CI/CD pipeline
Live Vercel deployment and debugging (including fixing a @/lib/api gitignore exclusion bug mid-deployment)

Prize Categories

Open Source AI — Built entirely on open-weight models (Ollama, Qwen, Llama, Gemma, BGE Embeddings). Zero proprietary closed APIs.
Best Use of AI — Deterministic + AI hybrid architecture solving real academic planning with zero hallucination guarantees.
Best Deployed Project — Live on Vercel (Next.js frontend) and GitHub Pages (showcase).
Student Developer — Built by a student, for a student.

Acceptance Criteria

✅ Register, login, and JWT session handling
✅ One-click seeded demo student account (demo@acadflow.dev)
✅ Academic Inbox (raw text, PDF upload, voice input)
✅ Open-source LLM extraction with zero-hallucination deterministic fallback
✅ Review & edit extracted items before saving
✅ Deterministic Priority Engine (RED / ORANGE / YELLOW / GREEN)
✅ Daily planner with study hour budget selector
✅ Signature Feature: Adaptive Replanning with plain-language trade-off explanation
✅ Workload estimation with personalized programming multipliers
✅ Course pages with strong/weak topic tracking and AI study recommendations
✅ Knowledge Base RAG with grounded source citations
✅ Project Mode with team roles and AI blocker warnings
✅ Long-term Goals with milestone checklists
✅ Workload Analytics with completion rates and insights
✅ Smart contextual notifications
✅ Docker Compose ready (PostgreSQL + pgvector + Ollama)
✅ 13 automated test cases (pytest)
✅ Light/Dark theme toggle with localStorage persistence
✅ Deployed live on Vercel and GitHub Pages

Built with love for every student who has ever missed a deadline they were certain they remembered.

AcadFlow — I Built an AI Academic Operating System for My Friend Who Drowns in Deadlines Every Semester

Divyanshi Gupta — Sun, 04 Oct 2026 14:45:31 +0000

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

What I Built

She does not lack information. She has too much, scattered across five apps, three portals, and a camera roll full of screenshots.

What it does:

Academic Inbox: Paste raw WhatsApp announcements, upload syllabus PDFs, or voice-dictate assignment requirements. Open-source LLMs extract structured tasks, courses, and deadlines.
Zero-Hallucination Priority Engine: Every task gets a mathematically computed priority score (RED / ORANGE / YELLOW / GREEN). If a deadline is not explicitly stated, it stays null — the system never invents one.
Daily Planner: Generates focus blocks within a customizable study-hour budget, with cognitive breaks.
Adaptive Replanning (Signature Feature): When Priya reports "I only finished 45 minutes of DBMS instead of 90", AcadFlow recalculates the entire schedule — safely shifting low-priority tasks to tomorrow while preserving imminent exam revision. It explains its trade-offs in plain language.
Knowledge Base (RAG): Upload lecture notes and study guides. Ask questions grounded in actual indexed documents with source citations.
Workload Analytics: Tracks completion rates and learns that Priya consistently takes 30% longer on programming assignments, automatically adjusting future estimates.
Goals & Projects: Long-term milestone tracking and collaborative project management with AI blocker warnings.

Demo

Live Frontend (Vercel):

https://acadflow-devchallenge1.vercel.app

GitHub Pages (Landing Showcase):

https://divyanshigupta786.github.io/Acadflow-devchallenge1/

Try the Pre-loaded Demo Student Account:

Email: demo@acadflow.dev
Password: demo123

Pre-loaded with 5 real CS courses, 12 realistic tasks, an active daily schedule, indexed study documents, and a collaborative AI project — ready to explore immediately.

Code

divyanshigupta786 / Acadflow-devchallenge1

AcadFlow — AI-Powered Academic Operating System

From academic chaos to clarity.

1. Product Philosophy: Not Another Chatbot

Students do not have a lack of academic information; they have an academic information overload problem. Academic information is scattered across:

WhatsApp messages
Google Classroom
College ERP & Portals
Emails & PDFs
Screenshots & handwritten notes
Project chat threads

AcadFlow replaces manual planning with an academic decision and planning engine powered by open-source AI.

The Core Loop

INPUT ──► UNDERSTAND ──► PRIORITIZE ──► PLAN ──► EXECUTE ──► MONITOR ──► REPLAN

2. Signature Feature: Adaptive Replanning

When a student reports:

"I only completed 45 minutes of DBMS." or "I lost 2 hours today."

AcadFlow does not simply…

View on GitHub

Project Structure

Acadflow-devchallenge1/
├── frontend/                 # Next.js 14 (App Router) + TypeScript + Tailwind
│   └── src/
│       ├── app/              # 17 pages: dashboard, tasks, inbox, courses, analytics...
│       ├── components/       # Sidebar, Navbar, ThemeToggle, Footer...
│       └── lib/              # api.ts, types.ts, utils.ts
├── backend/                  # Python 3.11 + FastAPI + SQLAlchemy
│   └── app/
│       ├── main.py           # Application entry point
│       ├── config.py         # Pydantic Settings + Supabase config
│       └── routers/          # Auth, tasks, courses, inbox, planner, AI endpoints
│           └── ai.py         # Ollama LLM + deterministic fallback + RAG
├── backend/tests/            # 13 test cases (pytest)
├── index.html                # Standalone self-contained landing page showcase
├── docker-compose.yml        # One-command stack: FastAPI + Next.js + PostgreSQL + Ollama
└── .github/workflows/        # CI + GitHub Pages automated deployment

How I Built It

Open-Source AI Architecture

AcadFlow is built around a dual-intelligence architecture that decouples AI assistance from deterministic business logic:

1. Local LLM Inference via Ollama

# backend/app/routers/ai.py
response = requests.post(
    f"{settings.OLLAMA_BASE_URL}/api/generate",
    json={
        "model": settings.OLLAMA_MODEL,  # qwen2.5:7b, llama3.2, mistral, gemma2
        "prompt": extraction_prompt,
        "stream": False,
    },
    timeout=60,
)

Supported models: Qwen 2.5:7b, Llama 3.2, Mistral 7B, Gemma 2, plus any OpenAI-compatible local endpoint.

2. Anti-Hallucination Rules (Hardcoded)

# The LLM is explicitly instructed:
# "If you are not 100% certain of the deadline from the text, set deadline to null."
# "Never invent, estimate, or assume deadlines."
# Inferred estimates are tagged ai_estimate=True and shown visually in the UI.

3. Deterministic Priority Engine (Zero LLM Involvement)

Priority Score = (Urgency + Importance + Workload + Dependency Risk + Exam Proximity)
                 ─────────────────────────────────────────────────────────────────────
                                   Completion Progress Factor

RED    >= 75  →  Imminent deadline (<24h), exam, or overdue
ORANGE 50-74  →  Due within 48h or blocking teammates
YELLOW 25-49  →  Standard runway assignments
GREEN  < 25   →  Extended deadlines or completed

4. Adaptive Replanning Engine

def replan(student_report: str, active_tasks: list, today_budget_minutes: int):
    # 1. Parse what was completed vs planned
    # 2. Recalculate remaining workload per task
    # 3. Identify tasks safely shiftable (low priority, distant deadline)
    # 4. Preserve imminent exam revision and high-stakes deadlines
    # 5. Return new schedule + plain-language trade-off explanation

5. Knowledge Base RAG

Documents are chunked, embedded with BGE Embeddings, stored in pgvector.
Queries retrieve top-k chunks by cosine similarity.
Every AI answer includes source citations linking back to the original document.

Tech Stack

Layer	Technology
Frontend	Next.js 14 (App Router), TypeScript, Tailwind CSS, Lucide Icons
Backend	Python 3.11, FastAPI, Pydantic v2, SQLAlchemy 2.0, Uvicorn
Database	SQLite (local dev) / PostgreSQL + pgvector / Supabase
AI Inference	Ollama — Qwen 2.5, Llama 3.2, Mistral, Gemma 2 + Deterministic Fallback
Embeddings & RAG	BGE Embeddings + cosine similarity via pgvector
UI Design	Cormorant Garamond + Poppins, cream/teal palette, dark/light theme
Containerization	Docker + Docker Compose
Deployment	Vercel (frontend) + GitHub Pages + GitHub Actions CI/CD
Tests	Pytest — 13 test cases

Why Does Open Innovation Matter?

1. Student Privacy Cannot Be Negotiated

2. Zero Cost = Universal Access

3. Deterministic Reliability Over Probabilistic Drift

4. Community Auditability for Academic Tools

My Agent Session

This project was built with Google Antigravity (AGY) AI coding assistant. The session covered:

Designing the deterministic priority scoring system and anti-hallucination pipeline
Building the Adaptive Replanning Engine
Full Next.js 14 App Router frontend with 17 pages
Real-time dark/light theme toggle with localStorage persistence
Supabase + PostgreSQL backend integration
GitHub Actions CI/CD pipeline
Live Vercel deployment and debugging (including fixing a @/lib/api gitignore exclusion bug mid-deployment)

Prize Categories

Open Source AI — Built entirely on open-weight models (Ollama, Qwen, Llama, Gemma, BGE Embeddings). Zero proprietary closed APIs.
Best Use of AI — Deterministic + AI hybrid architecture solving real academic planning with zero hallucination guarantees.
Best Deployed Project — Live on Vercel (Next.js frontend) and GitHub Pages (showcase).
Student Developer — Built by a student, for a student.

Acceptance Criteria

[x] Register, login, and JWT session handling
[x] One-click seeded demo student account (demo@acadflow.dev)
[x] Academic Inbox (raw text, PDF upload, voice input)
[x] Open-source LLM extraction with zero-hallucination deterministic fallback
[x] Review & edit extracted items before saving
[x] Deterministic Priority Engine (RED / ORANGE / YELLOW / GREEN)
[x] Daily planner with study hour budget selector
[x] Signature Feature: Adaptive Replanning with plain-language trade-off explanation
[x] Workload estimation with personalized programming multipliers
[x] Course pages with strong/weak topic tracking and AI study recommendations
[x] Knowledge Base RAG with grounded source citations
[x] Project Mode with team roles and AI blocker warnings
[x] Long-term Goals with milestone checklists
[x] Workload Analytics with completion rates and insights
[x] Smart contextual notifications
[x] Docker Compose ready (PostgreSQL + pgvector + Ollama)
[x] 13 automated test cases (pytest)
[x] Light/Dark theme toggle with localStorage persistence
[x] Deployed live on Vercel and GitHub Pages

Built with love for every student who has ever missed a deadline they were certain they remembered.