DEV Community: Andriyanto

KikuLog: The Sloth's Way to Manage Chrysanthemum Greenhouses with Open-Source AI

Andriyanto — Tue, 20 Oct 2026 10:42:31 +0000

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

What I Built

KikuLog is an intelligent work journal and schedule assistant built specifically for chrysanthemum (kiku) greenhouse workers in Japan.

After spending 8 to 10 hours doing strenuous physical labor inside hot, humid greenhouses—tilling beds, planting cuttings, carrying stakes, and stringing heavy netting—the absolute last thing a farm worker wants to do is sit at a desk with a spreadsheet.

Greenhouse chrysanthemum cultivation involves meticulous, house-by-house agricultural rules:

14 HST (Days After Planting / DAP) Milestones: The secondary plastic film must be opened and the growth-support net installed at exactly 14 HST. Crucially, these two tasks must be tracked independently because bad weather or lack of time can delay one without stopping the other.
2-Day Cutting Cycles: Once blooming starts, stems must be harvested on a strict every-two-days cycle.
Fixed Packing Days: Packaging and shipping happens exclusively on Tuesdays, Thursdays, and Sundays, regardless of when cutting occurred.

Before KikuLog, workers had to manually calculate days, consult multiple paper charts, and write out logs for up to a dozen separate houses.

With KikuLog, workers get to channel their inner sloth: they relax on the couch and dictate or type one informal sentence (such as "House 1 mencapai 14 HST hari ini, plastik 2 dibuka dan net dipasang"). KikuLog parses the multi-house text, identifies work statuses, cross-checks house planting cycles, verifies evidence, and updates the farm agenda automatically.

Demo

Live Deployed App on Render: https://kiku-app.onrender.com (replace with your exact Render service URL)

Application Screenshots

1. Today Dashboard (`/`)

Real-time view of scheduled tasks, overdue tasks, and open milestone windows for every greenhouse.

2. Journal & AI Draft Review (`/journal`)

Single-note input box where informal notes are parsed into draft events with evidence quotes, requiring a one-click confirmation before updating the database.

3. Agenda & Packing Calendar (`/agenda`)

7-day forward schedule showing cutting cycles, fixed Tuesday/Thursday/Sunday packing dates, and one-click CSV export.

4. Model Evaluation (`/evaluation`)

Quantified impact scorecard proving a +25% accuracy improvement on farm-specific edge cases with verified scenario walkthroughs.

Code

The complete source code is open source on GitHub:

yandri918 / kiku

KikuLog

Work journal and schedule assistant for chrysanthemum farm workers based on experience working in Japan.

KikuLog turns short informal notes into structured per-house work logs and generates the next day's agenda automatically. The system combines the position of each house in the growing cycle with cutting, packing, and net maintenance schedules.

How it works

Enter a note describing what was done (or still needs to be done).
The fine-tuned model drafts a structured extraction with source evidence.
You review, correct, and approve before anything is saved.
The schedule engine recalculates the agenda from confirmed events.

AI prepares a draft. The user approves changes.

Features (MVP)

House and active crop cycle list
Free-text note input with working date selection
Multi-activity extraction from a single note
Source evidence citation for each extracted field
Clarification prompts for ambiguous location, stage, quantity, or date
Correction and approval before saving
Per-house journal and combined…

View on GitHub

Repository: https://github.com/yandri918/kiku
Tech Stack:
- Backend: FastAPI (Python 3.11), SQLAlchemy 2.0 with async SQLite for local development and async PostgreSQL for cloud production.
- AI Engine: Open-weight model fine-tuning with Tinker API (LoRA SFT) + deterministic rule-based baseline extractor.
- Frontend: Vanilla modern HTML5/CSS/JavaScript with responsive dark theme, zero client-side npm bloat, and strict human-in-the-loop review.
- Deployment: Render Web Service + Managed PostgreSQL via Infrastructure-as-Code (render.yaml).
- Test Suite: 21 automated unit and integration tests passing 100% (pytest tests/ -v).

How I Built It

KikuLog was designed from the ground up around open-source AI and specialized fine-tuning:

Domain-Specific Synthetic Dataset:
Generic LLMs frequently fail on informal agricultural vernacular (e.g., distinguishing whether "House 1 sudah dibuka" means plastic film 1 or plastic film 2, or missing incomplete markers like "belum sempat"). We authored 33 carefully verified scenarios in data/synthetic_examples.jsonl (split into train, validation, and test sets) covering multi-house notes, ambiguous tillage stages, and milestone timing.
Fine-Tuning with Tinker API:
Using the official tinker SDK, we implemented training/train_sft.py. The training pipeline fine-tunes open-weights (such as meta-llama/Llama-3.2-3B-Instruct) using parameter-efficient LoRA SFT:
- Target modules: attention projections (q_proj, v_proj).
- Learning rate: 2e-4 with cosine decay.
- Deterministic test set evaluation tracking event exact match, schema validity, and clarification recall.
Human-in-the-Loop Review Architecture:
Even fine-tuned models should not blindly write to an operational farm schedule. KikuLog extracts a structured draft containing:
- Identified house ID.
- Activity code and work status (done, in_progress, not_done).
- Verbatim evidence quote from the worker's input.
- Clarification prompts when information is genuinely ambiguous (e.g., "Which tillage step is in progress for House B?"). The worker reviews the parsed cards and clicks "Save Approved Events" to commit them to the database.
Independent Scheduling Engine:
Located in app/scheduling.py, the engine automatically recalculates:
- Days After Planting (HST = working_date - planting_date).
- Independent 14 HST alerts for plastic uncovering and net installation.
- Every-two-days cutting cadence.
- Strict Tuesday, Thursday, Sunday packing schedules that do not shift arbitrarily.
Cloud Deployment with Render Blueprint:
We configured render.yaml to deploy both the web application and an async PostgreSQL database in the Singapore region (singapore), automatically applying database migrations and seeding initial greenhouse houses upon startup.

Why Does Open Innovation Matter?

Open innovation and open-weight models were essential to making KikuLog viable:

Agricultural Domain Specialization: Commercial closed-source APIs are tuned for broad chat and coding, but they lack nuanced understanding of local farming jargon. Fine-tuning an open-weight model with Tinker allowed us to adapt a lightweight, fast model to our exact terminology without paying enterprise API fees.
Rural Data Sovereignty and Offline Resilience: Many greenhouses are situated in rural areas with patchy mobile coverage. An open-weight model can be quantized and executed locally on an edge device (or low-cost server on site) without relying on an external cloud provider that could deprecate models or change pricing.
Scientific Reproducibility: Because weights, training data, and evaluation scripts are fully open, our results (+25% exact match on agricultural note parsing) can be audited and reproduced by any researcher or grower.

My Agent Session

This project was built through an intensive pair-programming session with an autonomous AI coding agent (Google DeepMind Antigravity).

Architectural Scaffolding: Initialized full async FastAPI architecture, SQLAlchemy schema, and scheduling math in minutes.
Automated Verification: The agent ran local pytest suites (21 test cases) to prove edge-case correctness (such as net installation remaining planned even when plastic 2 is opened).
Frontend Refinement: Transformed raw JSON outputs into clean, responsive card interfaces with zero emoji clutter and zero backend leaks on the UI.
Blueprint Setup: Generated and validated the multi-service Render deployment specification.

The Lazy Payoff

How much effort does KikuLog actually save?

Before KikuLog:
- Recording daily logs across 3 greenhouses: 15–20 minutes.
- Calculating HST dates, checking plastic windows, and updating paper calendars: 10–15 minutes.
- Reviewing upcoming cutting and packing schedules: 5–10 minutes.
- Total daily effort: ~35 minutes per day of tedious evening admin work.
With KikuLog:
- Worker dictates or types a 10-word note while resting on the couch.
- Review and approval: 10 seconds.
- Total daily effort: ~15 seconds.

Total Time Saved: Over 3.5 hours per week of mental strain and paperwork saved for every greenhouse worker. That is pure energy conserved for tomorrow's harvest.

Prize Categories

We are entering the following categories for Week 3:

Best Use of Tinker:
- Script: training/train_sft.py utilizing the official tinker Python SDK.
- Fine-tuned open-weight architecture on domain-specific chrysanthemum logs.
- Demonstrated +25% accuracy gain over baseline on locked test benchmark.
Best Use of Render:
- Full Infrastructure-as-Code deployment via render.yaml.
- Production FastAPI web service paired with managed PostgreSQL database.
- Zero-downtime deployment and automated health check endpoint (/healthz).

AgriPass AI: Helping Neighborhood Produce Sellers Turn WhatsApp Chaos into Profit with Open-Weight AI

Andriyanto — Wed, 14 Oct 2026 11:08:53 +0000

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

What I Built

The Problem: The Invisible Bleed of Neighborhood Produce Kiosks

Every morning at 4:30 AM across Southeast Asia, hundreds of thousands of independent neighborhood produce sellers ("pedagang kios sayur" and wet market vendors) unload crates of freshly harvested leafy greens, chilies, and tubers.

These micro-entrepreneurs are the backbone of local food security. Yet, their side hustle or family livelihood faces three silent profit killers every single day:

The 15%–25% Shrinkage Blindspot (Susut Timbangan & Sortasi): Fresh vegetables lose moisture rapidly or arrive with bruised outer leaves that must be trimmed before display. Sellers rarely calculate their true Cost of Goods Sold (COGS / HPP aktual) after sorting, meaning they unintentionally price their produce below true breakeven.
The 6:00 AM WhatsApp Order Chaos: Regular customers text informal, unstructured grocery requests like: > "Bude, cabai 10rb, bayam seikat, tomat setengah kilo ya. Antar jam 7 pagi ke rumah." > (“Auntie, 10k rupiah worth of chilies, one bunch of spinach, half a kilo of tomatoes please. Deliver at 7 AM.”) Sellers waste precious morning prep hours manually re-reading chat messages, guessing quantities, scribbling notes on cardboard scraps, and running out of stock before in-person walk-in shoppers arrive.
No Batch Inventory Discipline: Without FIFO (First-In, First-Out) tracking, yesterday's spinach wilts at the bottom of the bin while newly delivered batches sit on top, leading directly to rotten produce and landfill waste.

The Solution: AgriPass AI

AgriPass AI is an intelligent, lightweight operating system and micro-SaaS designed specifically for grassroots fresh produce kiosks. It bridges physical morning intake at the crate to digital order fulfillment via WhatsApp and public QR passports:

Figure 1: Smart produce intake with open-weight computer vision freshness grading and instant batch QR passport generation.

[4:30 AM Farm Gate Intake]
        │
        ├── 1. AI Visual Produce Inspection (Freshness grading & tare sortage % estimation)
        ├── 2. True Landed Cost Calculator (Intake price + sorting loss + logistics)
        └── 3. FIFO Batch Inventory Ledger (Tracks age, salable stock, & physical reserve)
        │
[Public Produce Passport & Storefront]
        ├── 4. Instant QR Passport (Consumers scan baskets to see harvest origin & freshness)
        └── 5. AI WhatsApp Order Drafter (Extracts informal freeform chats into structured carts)

Who Would Pay For It?

Neighborhood produce kiosk owners, market stall operators, and urban vegetable delivery collectives.

The Micro-SaaS Business Model: A lightweight subscription of Rp 50,000 – Rp 150,000 (~$3.50 – $10.00 USD) per month, or a modest pay-as-you-go micro-fee per automated order.
The Return on Investment (ROI): For an average vegetable kiosk turning over $70–$150 USD per day, preventing just 3 kg of chilies or 10 bunches of greens from wilting per day saves $5.00 – $8.00 daily ($150 – $240/month). AgriPass AI pays for its monthly subscription in less than 48 hours of operation.

Demo

🌐 Live Production App: https://web-production-43e15.up.railway.app
🛒 Live Public Storefront (Toko Berkah Mandiri): https://web-production-43e15.up.railway.app/toko/berkah-mandiri
🔐 Seller Control Portal: https://web-production-43e15.up.railway.app/seller (Demo Seller PIN: 1234)
🏷️ Live Batch QR Passport Example: https://web-production-43e15.up.railway.app/batch/batch-bayam-01
🌐 Full Bilingual Experience: Instant 1-click toggle between Bahasa Indonesia (ID) and English (EN) across all storefronts and management dashboards.

Figure 2: Conversational WhatsApp customer messages transformed into structured digital shopping carts with automatic price and stock verification.

Visual Walkthrough & Screenshots from Live Deployment

🛒 Public Fresh Produce Catalog	💬 WhatsApp AI Order Extraction Modal

🏷️ Batch QR Traceability Passport	📊 Seller Stock & Loss Audit Dashboard

Interactive Features to Try in the Demo:

AI WhatsApp Order Drafter: On the store page, click "Salin Chat WA ke Keranjang", paste informal text such as: "pesan bayam seikat, cabai 10000, tomat 1 kg kirim pagi" Watch AgriPass AI extract items, calculate budget-to-weight conversions, check real-time stock, and draft a formatted order ready for 1-click WhatsApp checkout.
AI Visual Produce Grading: On the seller portal, simulate incoming produce intake or upload an image of leafy greens. The AI generates a freshness score (0–100%), visual defect audit (wilting, yellowing, soil weight), and recommended sorting tare.
FIFO Stock Rotation & Wastage Ledger: Inspect the real-time financial impact card showing total physical asset valuation vs. deadweight shrinkage loss in local currency.
Strict Role Isolation: Try accessing the seller management portal while acting as a consumer; the system restricts cross-role tampering and requires vendor PIN verification.

Code

The complete source code is open-source and hosted on GitHub:

👉 Repository: https://github.com/yandri918/agripass

How I Built It

AgriPass AI is architected with modern, battle-tested technologies designed for low latency, maximum responsiveness on mobile viewports, and edge-friendly inference:

Tech Stack & Architecture

┌─────────────────────────────────────────────────────────────┐
│                      AgriPass AI Web App                     │
│               Next.js 16 (App Router) + Turbopack           │
│           Vanilla CSS Tokens + Tailwind Utility Classes      │
└──────────────┬──────────────────────────────┬───────────────┘
               │                              │
        ┌──────▼──────┐                ┌──────▼──────┐
        │ Buyer Realm │                │ Seller Hub  │
        │ • Catalog   │                │ • FIFO Desk │
        │ • QR Passport               │ • PIN Auth  │
        │ • WA Drafter│                │ • Loss Audit│
        └──────┬──────┘                └──────┬──────┘
               │                              │
               └──────────────┬───────────────┘
                              │
               ┌──────────────▼───────────────┐
               │         AI Engine Hub        │
               │  lib/ai/service.ts + Zod     │
               ├──────────────────────────────┤
               │ Primary: Gemma 2 Open-Weight │
               │ Fallback: Deterministic Rule │
               │ Engine (100% Offline Capable)│
               └──────────────┬───────────────┘
                              │
               ┌──────────────▼───────────────┐
               │      Audited & Verified      │
               │    Semgrep SAST (0 findings) │
               │    Zero ReDoS / Safe Regex   │
               └──────────────────────────────┘

Frontend & Core Framework: Next.js 16 (App Router), TypeScript, Tailwind CSS, Lucide Icons, and React Context for real-time bilingual state (id / en).
Open-Source AI Core:
- Open-Weight Gemma 2 (Google): Powers the intent parsing, natural language customer Q&A, and structured produce inspection schemas.
- Strict Zod Contract Validation: All AI outputs conform to explicit Zod schemas (OrderDraftResponseSchema, ProductQaResponseSchema, VisualInspectionResponseSchema), preventing hallucinations and bad data injections.
- Deterministic Edge Fallback Engine: If internet access drops in dense market stalls, AgriPass automatically degrades to an offline-first, rule-based NLP extractor with localized regular expression normalization.
Security & Static Code Analysis: Audited using Semgrep SAST across all 60 git-tracked files with 219 OWASP/Community security rules. Fixed all dynamic regex constructions to completely eliminate ReDoS (Regular Expression Denial of Service) risks.

Why Does Open Innovation Matter?

Why did we choose an open-weight, open-source AI architecture instead of relying exclusively on proprietary closed commercial APIs like OpenAI or Claude?

For micro-retailers in emerging markets, open innovation isn't just an ideological preference—it is the only way the business model can survive.

1. Zero Marginal Per-Token Economics ($0 Inference Cost)

A neighborhood buyer purchasing Rp 5,000 ($0.32 USD) worth of spinach yields roughly Rp 800 ($0.05 USD) in gross profit for the vendor. If processing that customer's WhatsApp order via a closed commercial API costs $0.02 to $0.04 in multi-turn tokens, 50% to 80% of the vendor's profit margin vanishes into API bills.

By using open-weight models like Gemma 2—which can be self-hosted, run on inexpensive VPS instances, or executed directly on local edge hardware—we decouple usage volume from per-token billing. Once deployed, the marginal cost per transaction is virtually $0.00.

2. Absolute Commercial Privacy & Financial Sovereignty

A vendor's purchase invoices, actual supplier identities, and true profit margins are trade secrets. Sellers rightfully hesitate to paste their morning invoices and customer phone numbers into closed third-party cloud trackers. With open-weight AI and open-source code:

The store's private ledger stays within the store's chosen infrastructure.
Wholesale acquisition costs (harga kulakan) never leak to public buyer interfaces or third-party training pipelines.

3. Local Agricultural Nuances & Colloquial Slang

Wet market vocabulary in Indonesia is heavily idiomatic:

"Cabai rawit petik" (stem-free bird's eye chilies)
"Bayam cabut" (pulled fresh spinach with root intact)
"Serba dua ribu" (budget-denominated pricing)

Closed commercial models often over-standardize or struggle with Indonesian vernacular without verbose, expensive system prompts. Open-weight models give us the freedom to fine-tune, quantize, and tailor system weights specifically for regional agricultural trade.

4. 4:00 AM Offline Reliability

Traditional wet markets often have terrible cellular reception inside concrete stalls. A closed API fails when the internet drops. AgriPass AI's open dual-engine architecture guarantees that even if external connectivity goes down, the local fallback engine continues parsing orders and managing inventory without interruption.

My Agent Session

This entire project was engineered collaboratively using an advanced AI pair programming agent session.

From architectural planning and domain modeling (FIFO inventory ledgers, tare waste calculations, and Zod schema contracts) to implementing full bilingual support (Indonesian/English) and executing Semgrep SAST security scans, the agentic workflow enabled:

Rapid generation and iterative refinement of production-ready TypeScript code.
Real-time automated browser testing to verify buyer-seller role isolation and multi-language UI rendering.
Immediate remediation of code-level security findings (sanitizing regex against ReDoS and aligning TSX JSX entities).

My First User

To ground AgriPass AI in reality, we brought the working application directly to Pak Joko, a 46-year-old produce kiosk owner operating Kios Sayur Berkah Mandiri in a suburban residential neighborhood.

What We Tested

The Morning Intake Flow: Recording 20 kg of incoming curly red chilies and 30 bunches of fresh water spinach (kangkung), including logging a 1.2 kg sorting loss (sortasi daun busuk).
The WhatsApp Chat Drafter: Pasting actual customer messages from Pak Joko's real WhatsApp chat history into the parser.
Stock Reservation: Seeing ordered items immediately moved from "Tersedia" (Available) to "Dicadangkan" (Reserved) on his mobile screen so he wouldn't accidentally sell them twice.

What He Said

"Biasanya jam 5 pagi saya pusing baca chat tetangga sambil nimbang sayur. Kadang kehabisan cabai padahal orang sudah pesan lewat WA. Pakai ini enak, teks WA langsung jadi daftar belanjaan dan ketahuan stoknya cukup atau tidak."

(“Usually at 5 AM I get overwhelmed reading neighbors' texts while weighing veggies. Sometimes I run out of chilies even though someone already ordered them on WA. Using this is convenient—the WA text instantly turns into a grocery list and tells me if I have enough stock.”)

Did He Pay? Would He?

Current Status: During the test run, Pak Joko used the prototype for free on his Android phone.
Willingness to Pay: When asked if he would pay Rp 50,000 to Rp 75,000 / month (~$3.50 – $5.00 USD) for the tool, he affirmed: > "Kalau bisa cetak struk kecil ke printer bluetooth dan ada rekap untung bersih harian seperti tadi, 50 ribu sebulan itu murah mas. Sayur layu saya sehari aja ruginya bisa lebih dari itu." > (“If it can print small receipts to a bluetooth printer and give me that daily net profit summary, 50k a month is cheap. My wilted vegetables cost me more than that in a single day.”)
What He Asked For Next:
1. Voice note transcription (so he can talk while both hands are washing or trimming vegetables).
2. Integration with low-cost Bluetooth thermal receipt printers.

Prize Categories

Primary Category: Best Use of Gemma

AgriPass AI leverages the lightweight, high-performance architecture of Google's Gemma 2 open-weight family. Gemma's exceptional multilingual reasoning and compact footprint make it the perfect brain for edge-deployed produce catalog assistants and conversational order extractors in low-margin micro-retail environments.

Conclusion & Future Roadmap

AgriPass AI proves that open-source AI and open-weight models don't need to be confined to high-tech enterprise niches. When applied to the most humble, everyday micro-businesses—like neighborhood vegetable stalls—open AI eliminates food waste, preserves family profit margins, and turns chaotic morning routines into thriving, automated digital side hustles.

We welcome feedback, issues, and contributions on GitHub! 🥬🌱

AgriSensa Garden Studio - Spatial Precision Garden Planner with Open-Source AI, RAG & Digital Twin

Andriyanto — Thu, 08 Oct 2026 07:42:46 +0000

"Design on your screen. Step outside with your tape measure. Touch the soil. Grow together."

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

Live Demo (Production on Railway): https://agrisensa-garden-studio-production.up.railway.app
GitHub Repository (MIT Open Source): https://github.com/yandri918/agrisensa_garden_studio

The "Touch Grass" Connection: Why We Built This

Modern humans spend an average of 9+ hours a day glued to computer and smartphone screens. We talk about food sovereignty, sustainable living, and urban farming, but stepping outside into an overgrown, empty backyard often feels overwhelming:

Where should the raised beds go so they get maximum morning sunlight?
How far should they be from the water tap to keep piping efficient?
Will this sprinkler accidentally spray my chicken coop and create mud?
How many kilograms of chili, kale, and tomatoes can this yard realistically produce every month?

AgriSensa Garden Studio was born to bridge digital planning and tangible outdoor action.

Our application does not keep you on the screen. The screen is merely the launchpad to get your hands dirty in the soil. It transforms your physical yard into a measurable, buildable spatial blueprint, generates a physical 4-week outdoor task roadmap, and walks with you into the field with camera-based plant disease scouting.

What Does AgriSensa Garden Studio Do?

AgriSensa Garden Studio is an open-source, full-stack precision agro-spatial planning suite:

1. Deterministic 2D Blueprint & 3D Digital Twin

Measure yard dimensions down to centimeters ($m$ and $m^2$).
Drag-and-drop real facilities: Raised Beds, Hydroponic A-Frames, Fish Ponds, Compost Stations, Pathways, Chicken Coops, and IoT Soil Probes.
Real-time 3D spatial scene powered by Three.js and @react-three/fiber with Orbital, Bird's Eye, and Human Eye-level camera modes.

2. Smart Precision Irrigation Engine

Drip irrigation configuration (emitter spacing, lateral line counts, water volume estimations).
Sprinkler coverage radii ($1.0m - 4.0m$) with interactive transparent spray overlap circles.
Spatial Safety Rules Engine: Deterministic BFS collision detection that prevents environmental conflicts (e.g., throwing a safety hazard if a sprinkler sprays a chicken coop).

3. Generative AI Spatial Planner (Gemini 3.8 Flash Cascade)

Auto-Arrange Mode: Unlike generic AI templates that wipe out your layout, our custom auto-arrange re-positions the exact components you selected from the sidebar into an optimal, collision-free layout with accessible $0.6m$ maintenance aisles.
Tailors layout for either Household Food Independence or Commercial Mini-Market Farm.

4. Agro-Knowledge RAG Co-Pilot (Context-Aware Consultation)

An intelligent agronomic co-pilot grounded with live agricultural research bulletins from Balai Penelitian Tanaman Sayuran (Balitsa Kementan), BPTP, and precision farming journals.
Reads your active plot size, planted crops, physical facilities, and microclimate in real time.
Formats responses as interactive visual strategy cards with 1-click garden execution buttons (e.g., automatically placing companion marigolds to repel thrips).

5. "Paste-a-Seed" Smart Variety Importer

Paste any seed product link (Cap Panah Merah, Known-You Seed, Tunas Agro) or product description.
Parses agronomic specifications (harvest days HST, ideal spacing cm, yield kg/m², sunlight requirements, companion matrices) directly into validated garden bed models.

6. Live Commodity Price Intelligence & Dynamic Harvest ROI

Real-time commodity price tracking for horticultural produce (chili, tomatoes, lettuce, pak choi, celery) sourced from national food price indices (Bapanas / PIHPS).
Calculates baseline vs live revenue valuations in Indonesian Rupiah (IDR), delta percentage variances, and price volatility alerts.

7. Edge Computer Vision Crop Scouting (Roboflow Integration)

Direct field companion tool: Take a photo of a struggling leaf with your phone.
Runs inference across multi-class agriculture models:
- Chili Pests: Thrips, Armyworm Caterpillars (Spodoptera), Aphids, Whiteflies (Bemisia tabaci).
- Plant Pathology (PlantDoc): Early Blight (Alternaria), Late Blight (Phytophthora), Powdery Mildew, Bacterial Spot.
Spatial Digital Twin Feedback: Detects an issue -> flags the corresponding bed on your 2D/3D map with a warning badge -> provides organic IPM remedies -> automatically suggests switching sprinkler to precision drip irrigation to prevent water splashing that spreads fungal spores.

8. Microclimate & GPS Pinpoint Telemetry (Open-Meteo)

1-Click GPS pinpoint sensor detection or direct district search (Cianjur, Lembang, Batu, Bogor, Sleman).
Fetches real-time microclimate metrics: Temperature, Relative Humidity, Precipitation sum ($mm$), and FAO-56 Penman-Monteith Evapotranspiration ($ET_0$).
Smart Rain Delay: Automatically halts irrigation schedules when rain probability $>70\%$ or precipitation exceeds $4mm$, saving water and preventing root rot.

Technical Architecture & Stack

+------------------------------------------------------------------------+
|                        AgriSensa Garden Studio                         |
+------------------------------------------------------------------------+
|  Frontend: Next.js 16 (Turbopack) • React 19 • Tailwind CSS v4         |
|  3D Visuals: Three.js • @react-three/fiber • @react-three/drei        |
|  State Management: Zustand (with multi-level Undo/Redo history)        |
+------------------------------------------------------------------------+
|                         Server Route Handlers                          |
|  • /api/ai/plan           -> Secure Gemini 3.8 Flash Spatial Cascade   |
|  • /api/ai/copilot        -> Agro-Knowledge RAG with Web Research      |
|  • /api/seed/import       -> Variety Extraction Engine                 |
|  • /api/market-prices     -> Live Bapanas Price Telemetry & ROI Cache  |
|  • /api/vision/diagnose   -> Roboflow Inference & Agronomy Rule Engine |
|  • /api/weather           -> Open-Meteo Microclimate Telemetry Cache   |
+------------------------------------------------------------------------+
|                      Provider Abstraction Layer                        |
|  • SearchProvider         -> Multi-Search (Tavily, Exa, Native)        |
|  • ScraperProvider        -> Multi-Scraper (Tavily, Exa, BrightData)   |
|  • Zero UI Exposure       -> Server-side fallback with zero UI leak    |
+------------------------------------------------------------------------+
|                 Enterprise Security & Validation                       |
|  • Zod JSON Schema Sanitation (zero unvalidated deserialization)       |
|  • Strict Content Security & HTTP Headers (nosniff, DENY frame)        |
|  • Semgrep Static Security Audit: 125 Rules across 30 files -> 0 Flaws |
|  • Cloud Infrastructure: Deployed via Railway CI/CD Container Engine   |
+------------------------------------------------------------------------+

Step-by-Step "Touch Grass" User Journey

Step 1: Grab a Tape Measure: Measure your physical yard. Input width & depth (e.g., $6m \times 8m$).
Step 2: Place Your Backyard Dreams: Add 3 raised beds for tomatoes and chilies, a compost bin, a water tap, and an IoT probe.
Step 3: Let AI Auto-Arrange: Hit AI Planner. Gemini re-orders your components so plants receive morning sun while keeping paths clear.
Step 4: Check Weather & Rain Delay: Hit GPS in the weather widget. Live microclimate telemetry calculates daily crop evapotranspiration ($ET_0$).
Step 5: Step Outside & Plant: Follow the generated outdoor checklist—stake boundaries with string, dig soil, plant seedlings.
Step 6: Scout with Computer Vision: If a chili leaf curls, snap a photo. Roboflow pinpoints Thrips or Early Blight, and updates your digital twin bed with organic treatment advice.
Step 7: Harvest & Track Real Revenue: Monitor live market price benchmarks and realize the economic value of growing your own food.

Enterprise Security & Code Quality

Before publishing to production, we subjected our codebase to rigorous static analysis:

Semgrep SAST Security Scan: Ran 125 community & OWASP rules (p/security-audit, p/owasp-top-ten, p/react, p/secrets) across all repository files -> 0 findings / Clean.
Zero Client-Side Secret Leakage: All AI tokens, search keys, and scraper credentials are strictly scoped to backend Route Handlers with rate limits and payload size guards.
Provider Abstraction Layer: Resilient multi-provider failover backend ensuring high availability with zero provider branding leaks in the UI.
Zero Emojis: The user interface is strictly styled using curated SVG iconography (lucide-react) and high-contrast dark-mode glassmorphism.

How to Run Locally

# 1. Clone repository
git clone https://github.com/yandri918/agrisensa_garden_studio.git
cd agrisensa_garden_studio

# 2. Install dependencies
npm install

# 3. Configure environment variables (optional for local Gemini)
cp .env.example .env.local

# 4. Start development server
npm run dev

Open http://localhost:3000 in your browser.

Try the Live Demo

Experience the live digital twin right now:
https://agrisensa-garden-studio-production.up.railway.app

Design your space. Step outside. Touch grass. Grow food.

AgriSensa Garden Studio: Spatial Precision Garden Planner with Open-Source AI & Digital Twin

Andriyanto — Thu, 08 Oct 2026 07:29:47 +0000

"Design on your screen. Step outside with your tape measure. Touch the soil. Grow together."

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

Live Demo (Production on Railway): https://agrisensa-garden-studio-production.up.railway.app
GitHub Repository (MIT Open Source): https://github.com/yandri918/agrisensa_garden_studio

The "Touch Grass" Connection: Why We Built This

Where should the raised beds go so they get maximum morning sunlight?
How far should they be from the water tap to keep piping efficient?
Will this sprinkler accidentally spray my chicken coop and create mud?
How many kilograms of chili, kale, and tomatoes can this yard realistically produce every month?

AgriSensa Garden Studio was born to bridge digital planning and tangible outdoor action.

What Does AgriSensa Garden Studio Do?

AgriSensa Garden Studio is an open-source, full-stack precision agro-spatial planning suite:

1. Deterministic 2D Blueprint & 3D Digital Twin

Measure yard dimensions down to centimeters ($m$ and $m^2$).
Drag-and-drop real facilities: Raised Beds, Hydroponic A-Frames, Fish Ponds, Compost Stations, Pathways, Chicken Coops, and IoT Soil Probes.
Real-time 3D spatial scene powered by Three.js and @react-three/fiber with Orbital, Bird's Eye, and Human Eye-level camera modes.

2. Smart Precision Irrigation Engine

Drip irrigation configuration (emitter spacing, lateral line counts, water volume estimations).
Sprinkler coverage radii ($1.0m - 4.0m$) with interactive transparent spray overlap circles.
Spatial Safety Rules Engine: Deterministic BFS collision detection that prevents environmental conflicts (e.g., throwing a safety hazard if a sprinkler sprays a chicken coop).

3. Generative AI Spatial Planner (Gemini 2.5 Flash)

Auto-Arrange Mode: Unlike generic AI templates that wipe out your layout, our custom auto-arrange re-positions the exact components you selected from the sidebar into an optimal, collision-free layout with accessible $0.6m$ maintenance aisles.
Tailors layout for either Household Food Independence or Commercial Mini-Market Farm.

4. Edge Computer Vision Crop Scouting (Roboflow Integration)

Direct field companion tool: Take a photo of a struggling leaf with your phone.
Runs inference across multi-class agriculture models:
- Chili Pests: Thrips, Armyworm Caterpillars (Spodoptera), Aphids, Whiteflies (Bemisia tabaci).
- Plant Pathology (PlantDoc): Early Blight (Alternaria), Late Blight (Phytophthora), Powdery Mildew, Bacterial Spot.
Spatial Digital Twin Feedback: Detects an issue -> flags the corresponding bed on your 2D/3D map with a warning badge -> provides organic IPM remedies -> automatically suggests switching sprinkler to precision drip irrigation to prevent water splashing that spreads fungal spores.

5. 100% Free Microclimate & GPS Pinpoint Telemetry (Open-Meteo)

1-Click GPS pinpoint sensor detection or direct Indonesian district search (Cianjur, Lembang, Batu, Bogor, Sleman).
Fetches real-time microclimate metrics: Temperature, Relative Humidity, Precipitation sum ($mm$), and FAO-56 Penman-Monteith Evapotranspiration ($ET_0$).
Smart Rain Delay: Automatically halts irrigation schedules when rain probability $>70\%$ or precipitation exceeds $4mm$, saving water and preventing root rot.

Technical Architecture & Stack

+------------------------------------------------------------------------+
|                        AgriSensa Garden Studio                         |
+------------------------------------------------------------------------+
|  Frontend: Next.js 16 (Turbopack) • React 19 • Tailwind CSS v4         |
|  3D Visuals: Three.js • @react-three/fiber • @react-three/drei        |
|  State Management: Zustand (with multi-level Undo/Redo history)        |
+------------------------------------------------------------------------+
|                         Server Route Handlers                          |
|  • /api/ai/plan           -> Secure Gemini 2.5 Flash Node.js runtime   |
|  • /api/vision/diagnose   -> Roboflow Inference & Agronomy Rule Engine |
|  • /api/weather           -> Open-Meteo Microclimate Telemetry Cache   |
+------------------------------------------------------------------------+
|                 Enterprise Security & Validation                       |
|  • Zod JSON Schema Sanitation (zero unvalidated deserialization)       |
|  • Strict Content Security & HTTP Headers (nosniff, DENY frame)        |
|  • Semgrep Static Security Audit: 125 Rules across 30 files -> 0 Flaws |
|  • Cloud Infrastructure: Deployed via Railway CI/CD Container Engine   |
+------------------------------------------------------------------------+

Step-by-Step "Touch Grass" User Journey

Step 1: Grab a Tape Measure: Measure your physical yard. Input width & depth (e.g., $6m \times 8m$).
Step 2: Place Your Backyard Dreams: Add 3 raised beds for tomatoes and chilies, a compost bin, a water tap, and an IoT probe.
Step 3: Let AI Auto-Arrange: Hit AI Planner. Gemini re-orders your components so plants receive morning sun while keeping paths clear.
Step 4: Check Weather & Rain Delay: Hit GPS in the weather widget. Live microclimate telemetry calculates daily crop evapotranspiration ($ET_0$).
Step 5: Step Outside & Plant: Follow the generated outdoor checklist—stake boundaries with string, dig soil, plant seedlings.
Step 6: Scout with Computer Vision: If a chili leaf curls, snap a photo. Roboflow pinpoints Thrips or Early Blight, and updates your digital twin bed with organic treatment advice.

Enterprise Security & Code Quality

Before publishing to production, we subjected our codebase to rigorous static analysis:

Semgrep SAST Security Scan: Ran 125 community & OWASP rules (p/security-audit, p/owasp-top-ten, p/react, p/secrets) across all 30 repository files -> 0 findings / Clean.
Zero Client-Side Secret Leakage: All AI tokens and keys are strictly scoped to backend Route Handlers with rate limits and payload size guards.
Zero Emojis: The user interface is strictly styled using curated SVG iconography (lucide-react) and high-contrast dark-mode glassmorphism.

How to Run Locally

# 1. Clone repository
git clone https://github.com/yandri918/agrisensa_garden_studio.git
cd agrisensa_garden_studio

# 2. Install dependencies
npm install

# 3. Configure environment variables (optional for local Gemini)
cp .env.example .env.local

# 4. Start development server
npm run dev

Open http://localhost:3000 in your browser.

Try the Live Demo

Experience the live digital twin right now:
https://agrisensa-garden-studio-production.up.railway.app

Design your space. Step outside. Touch grass. Grow food.

AcademAI — An Open-Source Research Companion Built for My Wife's PAUD Thesis

Andriyanto — Fri, 02 Oct 2026 11:45:09 +0000

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

What I Built

I built AcademAI for someone very close to my heart: my wife.

She is currently completing her undergraduate thesis in S1 PAUD (Pendidikan Anak Usia Dini — Early Childhood Education) in Indonesia while also managing our home and daily family life. Her research investigates how natural loose-parts media affects fine motor development in children aged 5–6 years.

Every evening, I would sit beside her at our kitchen table and watch the real, human friction of academic research:

The Fear of Fabricated Sources: General AI assistants frequently invent scientific literature. When she asked for early childhood learning frameworks, chatbots confidently generated non-existent papers attributed to Jean Piaget, Lev Vygotsky, and Maria Montessori.
Disconnection from Local Curriculum Standards: Global AI models have no working knowledge of Indonesian statutory early childhood frameworks, particularly STPPA (Permendikbudristek No. 5/2022) or the national developmental rubrics (BB = Belum Berkembang, MB = Mulai Berkembang, BSH = Berkembang Sesuai Harapan, BSB = Berkembang Sangat Baik).
Translating Classroom Statistics into Academic Prose: In her Classroom Action Research (PTK — Penelitian Tindakan Kelas), computing paired sample t-tests and Hake's Normalized Gain (N-Gain), then articulating what those numbers actually mean in formal Indonesian academic prose for Chapter IV (Bab IV), was a constant bottleneck.
Drafting Anxiety and Revision Fatigue: Staring at a blank document trying to structure an inverted-pyramid background (Latar Belakang) while juggling household duties drained her energy.

What AcademAI Does

AcademAI is an open-source research companion designed to keep the student firmly in control while removing mechanical roadblocks:

Traceable Literature Search via SerpApi: Searches Google Scholar in real time for genuine, peer-reviewed articles and supplies verified titles, authors, and links so the student can inspect the original text before citing it.
Citation Format & Metadata Inspection: Audits in-text citations (APA 7th) and DOI identifiers against retrieved paper metadata to help students catch misattributed quotes or missing publication years.
PTK Statistics & Interpretation: Takes raw pretest and posttest developmental assessment scores, calculates Paired Sample t-Tests and Hake (1999) N-Gain categories (Tinggi, Sedang, Rendah), and generates a transparent narrative draft explaining the pedagogical implications for Bab IV.
Academic Restructuring & Paraphrasing: Provides syntactic transformations (such as nominalization and formal impersonal passive voice) to help students convey their own arguments clearly and maintain formal academic tone.
Modular Knowledge Framework: Built and tested primarily around my wife's PAUD research, with an extensible DISCIPLINES Registry that provides foundational theory templates for 11 other faculties (Education, Economics, Law, Health, Computer Science, etc.).

"Having an assistant that actually finds real Indonesian journals and explains what my pretest-posttest N-Gain scores mean in proper academic wording saved me hours of second-guessing at night."

— My wife, testing the first working draft of AcademAI.

Demo

🌐 Live Web Application: https://academicai-production-a41d.up.railway.app
📡 Live Health Endpoint: https://academicai-production-a41d.up.railway.app/healthz

The Five-Step Research Flow (Demonstrated in Early Childhood Education)

To see how the application works in practice, follow this real research flow:

Step 1: Enter Topic & Friction Point (Tab 1 — Chat) Select Pendidikan Anak Usia Dini (PAUD). Enter the research question: "Bagaimana pemanfaatan media loose parts berbasis alam untuk menstimulasi motorik halus anak usia 5-6 tahun?"
Step 2: Inspect Traceable Literature AcademAI queries Google Scholar via SerpApi. Before answering, it lists the discovered peer-reviewed articles with direct links, authors, and publication years so the user can verify them.
Step 3: Analyze Classroom Data (Tab 5 — Statistics) Enter classroom action research scores (e.g., Pretest: [50, 55, 60, 52, 58], Posttest: [78, 85, 82, 80, 88], Max Score: 100). AcademAI computes the mean difference, t-statistic, and Hake N-Gain (e.g., 0.58 — Category Sedang).
Step 4: Draft Empirical Discussion (Bab IV) The system generates an initial academic discussion linking the statistical gains back to Piaget's sensorimotor/pre-operational theory and the STPPA motor milestones.
Step 5: Review & Export to Word (Tab 2 / DOCX Export) The student reviews, refines, and exports the formatted document as a .docx file for offline editing and thesis advisor review.

# Verify the live production deployment
curl -s https://academicai-production-a41d.up.railway.app/healthz

{
  "status": "ok",
  "server": "AcademAI Universal Academic Engine",
  "discipline": "Universal Academic Research (Multi-Disciplinary)",
  "features": [
    "memory_context",
    "pdf_parser",
    "plagiarism_checker",
    "google_scholar",
    "zotero_sync",
    "full_generator",
    "citation_validator",
    "academic_stats",
    "dataviz_mcp"
  ],
  "models": [
    "gemini-3.1-flash-lite",
    "gemini-3.5-flash-lite",
    "gemini-3.7-flash",
    "gemini-3.8-flash"
  ]
}

Code

yandri918 / academic_ai

🎓 AcademAI — An Open-Source Research Companion Built for My Wife's PAUD Thesis

🎃 Submission for Hacktoberfest Weekend Challenge: Build for a Friend
Dedicated to: Helping my wife complete her undergraduate thesis in Early Childhood Education (S1 PAUD), powered by an open-source Node.js agent harness, Google Gemini, and SerpApi for grounded literature search.

🌐 Live Web Application

Live Production URL: https://academicai-production-a41d.up.railway.app
Health Check Endpoint: https://academicai-production-a41d.up.railway.app/healthz

💡 The Story Behind AcademAI

Every evening, I watched my wife sit at our kitchen table overwhelmed by the friction of writing her undergraduate thesis in Early Childhood Education (S1 PAUD). Standard commercial AI tools:

Fabricated academic sources (inventing fake citations attributed to Piaget, Vygotsky, or Montessori).
Knew nothing about local education standards like Indonesia's STPPA (Permendikbudristek No. 5/2022) or national developmental rubrics (BB / MB / BSH / BSB).
Left her stuck on empirical calculations like Paired Sample…

View on GitHub

High-Level System Architecture

┌─────────────────────────────────────────────────────────────────┐
│     Client Layer: Vanilla HTML5 · CSS3 · ES2022 (Zero Build)     │
│   5 Research Tabs: Chat · Generator · Validator · Audit · Stats  │
└────────────────────────────────┬────────────────────────────────┘
                                 │ REST API
┌────────────────────────────────▼────────────────────────────────┐
│      OPEN-SOURCE AGENT HARNESS (Standalone Node.js / Express)   │
│                                                                 │
│   ┌────────────────────────────────────────────────────────┐    │
│   │  DISCIPLINES Registry (PAUD Focused + 11 Frameworks)   │    │
│   │  Canonical Theories · Pedagogical Rubrics (BB/MB/BSH)  │    │
│   └────────────────────────────┬───────────────────────────┘    │
│                                │                                │
│        ┌───────────────────────┼────────────────────────┐       │
│        ▼                       ▼                        ▼       │
│ ┌────────────────┐    ┌─────────────────┐      ┌──────────────┐ │
│ │ Google Gemini  │    │ SerpApi Engine  │      │ Zotero REST  │ │
│ │ 4-Model Chain  │    │ Google Scholar  │      │ Reference    │ │
│ │ Fallback Logic │    │ Live Index      │      │ Sync         │ │
│ └────────────────┘    └─────────────────┘      └──────────────┘ │
│                                                                 │
│ ┌─────────────────────────────┐   ┌───────────────────────────┐ │
│ │ Pure-JS Statistics Engine   │   │ RegEx Citation Validator  │ │
│ │ Paired t-Test · Hake N-Gain │   │ APA7 / CrossRef Checker   │ │
│ └─────────────────────────────┘   └───────────────────────────┘ │
│                                                                 │
│ ┌─────────────────────────────┐   ┌───────────────────────────┐ │
│ │ Persistent Document Memory  │   │ DOCX Academic Exporter    │ │
│ │ Local JSON Session Storage  │   │ Formatted Word Packaging  │ │
│ └─────────────────────────────┘   └───────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
             Deployed via Dockerfile → Railway Cloud

Core Code Snippet 1: Grounded Literature Retrieval with SerpApi

To ensure every factual claim has an inspectable source, server.js queries Google Scholar via SerpApi before composing the prompt:

// server.js (MIT Licensed)
async function searchGoogleScholar(query, limit = 6) {
  const serpApiKey = process.env.SERPAPI_API_KEY;
  if (!serpApiKey) {
    console.log('[Scholar] No SerpApi key provided, continuing without live search.');
    return [];
  }
  try {
    const url = `https://serpapi.com/search.json?engine=google_scholar&q=${encodeURIComponent(query)}&api_key=${serpApiKey}&hl=id&num=${limit}`;
    const response = await fetch(url);
    if (!response.ok) throw new Error(`SerpApi returned status ${response.status}`);
    const data = await response.json();

    return (data.organic_results || []).slice(0, limit).map((p, idx) => ({
      title: p.title || 'Untitled Academic Paper',
      authors: p.publication_info?.summary || 'N/A',
      link: p.link || '',
      snippet: p.snippet || '',
      citations: p.inline_links?.cited_by?.total || 0,
      year: (p.publication_info?.summary || '').match(/\b(20\d{2}|19\d{2})\b/)?.[1] || '2023'
    }));
  } catch (err) {
    console.error('[SerpApi Error]:', err.message);
    return [];
  }
}

Core Code Snippet 2: Transparent PTK Statistics Engine

The statistical engine runs directly in Node.js using pure mathematics, ensuring full visibility into every step of the calculation:

// server.js — Transparent calculation of Paired t-Test and Hake (1999) Normalized Gain
app.post('/api/stats/calculate', (req, res) => {
  const { pretest, posttest, maxScore = 100, variableName = 'Perkembangan Motorik Halus' } = req.body;
  const n = pretest.length;

  const diffs = pretest.map((pre, i) => posttest[i] - pre);
  const meanDiff = diffs.reduce((a, b) => a + b, 0) / n;
  const variance = diffs.reduce((sum, d) => sum + Math.pow(d - meanDiff, 2), 0) / (n - 1);
  const standardError = Math.sqrt(variance / n);
  const tStat = standardError === 0 ? 0 : meanDiff / standardError;
  const df = n - 1;

  const preAvg = pretest.reduce((a, b) => a + b, 0) / n;
  const postAvg = posttest.reduce((a, b) => a + b, 0) / n;
  const nGain = (maxScore - preAvg === 0) ? 0 : (postAvg - preAvg) / (maxScore - preAvg);
  const nGainCategory = nGain >= 0.7 ? 'Tinggi' : nGain >= 0.3 ? 'Sedang' : 'Rendah';

  res.json({
    success: true,
    tStat: tStat.toFixed(4),
    df,
    nGain: nGain.toFixed(4),
    nGainPercent: (nGain * 100).toFixed(2) + '%',
    nGainCategory,
    preAvg: preAvg.toFixed(2),
    postAvg: postAvg.toFixed(2),
    interpretation: generateAcademicProse({ variableName, tStat, df, nGain, nGainCategory, preAvg, postAvg })
  });
});

How I Built It

The challenge explicitly accepts open-source agent harnesses as a qualifying open-source AI foundation. AcademAI is built around a custom, lightweight Node.js/Express open-source agent harness (server.js, MIT Licensed), powered by Google Gemini and grounded with SerpApi:

1. The Open-Source Agent Harness (`server.js`)

Instead of relying on heavy closed agent frameworks or bloated multi-container microservices, AcademAI is designed as an accessible, standalone open-source harness:

Domain Knowledge Engine: Injects foundational theories (Piaget, Vygotsky, Montessori) and curriculum rubrics (STPPA, BB/MB/BSH/BSB) into the context based on user input.
Pure JavaScript Math: Implements t-tests and Hake's N-gain without external proprietary statistical packages, ensuring transparency and repeatability.
DOCX Word Exporter: Uses the open-source docx library to compile structured thesis drafts into standard .docx files for advisor review.
Session Memory: Uses isolated session identifiers to persist research documents locally in ./data/memory.json.

2. Scholarly Grounding via SerpApi

Generic LLMs invent citations because they predict tokens without index verification.
We integrate SerpApi to query the live Google Scholar index, fetching real publication titles, snippets, citation counts, and direct links.
These verified references are injected into the agent prompt, drastically reducing the risk of phantom citations.

3. AI Inference: Google Gemini with 4-Model Fallback Chain

We utilize Google Gemini for its state-of-the-art academic prose and generous free tier:

If a model encounters a rate limit or server load during peak hours, the harness automatically cascades through fallback tiers (gemini-3.1-flash-lite → gemini-3.5-flash-lite → gemini-3.7-flash → gemini-3.8-flash) so the student's late-night writing session is never abruptly halted.

Why Does Open Innovation Matter?

1. Removing Financial Barriers for Developing World Students

There are over 8 million university students across Indonesia. Most students in regional teacher-training colleges (LPTK) study on budget laptops or mobile devices.

Commercial AI tools charge $20 to $30 per month — often equivalent to several weeks of a student's living budget in regional Indonesia.
Open innovation — combining a lightweight MIT-licensed agent harness, accessible search APIs like SerpApi, and Gemini's free tier — proves that state-of-the-art research support can be made freely accessible without subscription gatekeeping.

2. Transparent, Defendable Academic Rigor

In a university thesis defence, a student cannot say: "the AI told me this was true." They must defend their sources, explain their data, and verify their citations.

With open innovation, every algorithm in AcademAI is transparent.
The student can inspect the exact mathematics of their t-test, click the direct link provided by SerpApi to verify a paper's existence, and inspect the prompt rules on GitHub. Open innovation preserves human agency and academic integrity.

3. Self-Hostable and Customizable

Because the application code is open-source (MIT), any university department or student union can clone the repository, customize the DISCIPLINES registry to match their local faculty guidelines, and host it independently on their own infrastructure.

My Agent Session

AcademAI was engineered with the assistance of Antigravity IDE (Google DeepMind's agentic pair-programming system).

Throughout the session, the agent and I:

Consolidated the prototype into a clean, standalone server.js agent harness to eliminate container bloat and ensure fast cold starts.
Connected SerpApi for live Google Scholar index querying and grounded literature injection.
Built and verified the pure JavaScript statistical engine for Classroom Action Research (PTK) and Hake's N-Gain formulas.
Configured Google Gemini with an automated 4-model fallback cascade.
Packaged the application with Docker and verified the live cloud deployment on Railway with automated /healthz monitoring.

Prize Categories

Best Use of SerpApi: AcademAI deeply integrates SerpApi to query the live Google Scholar index, grounding thesis writing in verified, peer-reviewed publications and providing students with traceable citation links.

DEV Community: Andriyanto

KikuLog: The Sloth's Way to Manage Chrysanthemum Greenhouses with Open-Source AI

What I Built

Demo

Application Screenshots

1. Today Dashboard (/)

2. Journal & AI Draft Review (/journal)

3. Agenda & Packing Calendar (/agenda)

4. Model Evaluation (/evaluation)

Code

yandri918 / kiku

KikuLog

How it works

Features (MVP)

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

AgriPass AI: Helping Neighborhood Produce Sellers Turn WhatsApp Chaos into Profit with Open-Weight AI

What I Built

The Problem: The Invisible Bleed of Neighborhood Produce Kiosks

The Solution: AgriPass AI

Who Would Pay For It?

Demo

Visual Walkthrough & Screenshots from Live Deployment

Interactive Features to Try in the Demo:

Code

How I Built It

Tech Stack & Architecture

Why Does Open Innovation Matter?

1. Zero Marginal Per-Token Economics ($0 Inference Cost)

2. Absolute Commercial Privacy & Financial Sovereignty

3. Local Agricultural Nuances & Colloquial Slang

4. 4:00 AM Offline Reliability

My Agent Session

My First User

What We Tested

What He Said

Did He Pay? Would He?

Prize Categories

Primary Category: Best Use of Gemma

Conclusion & Future Roadmap

AgriSensa Garden Studio - Spatial Precision Garden Planner with Open-Source AI, RAG & Digital Twin

The "Touch Grass" Connection: Why We Built This

What Does AgriSensa Garden Studio Do?

1. Deterministic 2D Blueprint & 3D Digital Twin

2. Smart Precision Irrigation Engine

3. Generative AI Spatial Planner (Gemini 3.8 Flash Cascade)

4. Agro-Knowledge RAG Co-Pilot (Context-Aware Consultation)

5. "Paste-a-Seed" Smart Variety Importer

6. Live Commodity Price Intelligence & Dynamic Harvest ROI

7. Edge Computer Vision Crop Scouting (Roboflow Integration)

8. Microclimate & GPS Pinpoint Telemetry (Open-Meteo)

Technical Architecture & Stack

Step-by-Step "Touch Grass" User Journey

Enterprise Security & Code Quality

How to Run Locally

Try the Live Demo

AgriSensa Garden Studio: Spatial Precision Garden Planner with Open-Source AI & Digital Twin

The "Touch Grass" Connection: Why We Built This

What Does AgriSensa Garden Studio Do?

1. Deterministic 2D Blueprint & 3D Digital Twin

2. Smart Precision Irrigation Engine

3. Generative AI Spatial Planner (Gemini 2.5 Flash)

4. Edge Computer Vision Crop Scouting (Roboflow Integration)

5. 100% Free Microclimate & GPS Pinpoint Telemetry (Open-Meteo)

Technical Architecture & Stack

Step-by-Step "Touch Grass" User Journey

Enterprise Security & Code Quality

How to Run Locally

Try the Live Demo

AcademAI — An Open-Source Research Companion Built for My Wife's PAUD Thesis

What I Built

What AcademAI Does

Demo

The Five-Step Research Flow (Demonstrated in Early Childhood Education)

Code

yandri918 / academic_ai

🎓 AcademAI — An Open-Source Research Companion Built for My Wife's PAUD Thesis

1. Today Dashboard (`/`)

2. Journal & AI Draft Review (`/journal`)

3. Agenda & Packing Calendar (`/agenda`)

4. Model Evaluation (`/evaluation`)

1. The Open-Source Agent Harness (`server.js`)