FrostSprout: I Built a Local AI Garden Assistant That Gets You Outside, Not Staring at a Dashboard

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

The Problem: Your Garden Doesn't Need Another Dashboard

Imagine waking up on a cold autumn morning. The forecast says it might freeze overnight. You have spinach, garlic, carrots, and other crops growing outside.

You have three questions:

• Will frost threaten my garden tonight?
• Which plants need attention first?
• What should I physically do when I step outside?

A weather app gives you numbers. A gardening website gives you generic advice. An AI chatbot gives you another conversation to read.

I wanted to build something different: an AI assistant that tells you what to do, then gets out of your way.

Meet FrostSprout, an open-source, hyperlocal garden planning assistant built around one simple principle: the screen should be the shortest part of the experience.

What I Built

FrostSprout combines local AI, tabular machine learning, live weather data, and hands-free audio to turn microclimate conditions into a practical three-step garden action plan.

Instead of stopping at “There is a chance of frost,” it aims to answer: “Here is what you should check and protect before tonight.”

The default location is Panipat, Haryana, India, and the application supports ten cold-hardy autumn crops, with planting-depth guidance and practical outdoor observations.

1. From Weather Data to Actionable Decisions

FrostSprout collects available environmental features, including elevation, forecast temperatures, humidity, and cloud cover. It combines them with explicitly identified defaults for unavailable soil temperature, pressure, and rolling-temperature history.

The prediction layer estimates frost risk and produces inputs for the garden guide. The interface distinguishes real weather observations from hypothetical scenarios.

2. An AI Guide You Can Listen to Outside

The local Gemma model transforms numerical predictions into a concise, three-step task list.

Using the browser's native Web Speech API, FrostSprout reads the instructions aloud. You can listen while walking around your garden, checking leaves, touching the soil, and protecting vulnerable plants.

No external speech API is required.

3. A Printable Garden Field Card

Sometimes the best interface is paper.

FrostSprout includes print-specific styling that formats the plan into a compact field card. Print it, take it outside, and follow the steps without repeatedly unlocking your phone.

4. What-If Frost Scenarios

Want to explore what might happen if the temperature drops to 2°C?

The simulated mode lets you experiment with hypothetical conditions and observe how the application responds. It is explicitly labelled as simulated, so hypothetical weather is not confused with live observations.

5. An Outdoor Activity Log

A simple garden log records time spent outside and soil observations.

The goal isn't to maximise screen time or build another engagement dashboard. It is to encourage people to observe their environment and learn from their own garden.

Demo

Live demo: A public deployment is not currently linked. Run FrostSprout locally to explore its features.

The application includes live Open-Meteo weather, simulated frost scenarios, an audio walkthrough, printable field cards, and an outdoor log.

Code

GitHub repository: Shubham-cyber-prog/FrostSprout

Run it locally:

git clone https://github.com/Shubham-cyber-prog/FrostSprout.git
cd FrostSprout
pip install -r requirements.txt
python run.py

Open http://localhost:8000.

To reproduce the benchmark:

python backend/benchmark.py

The benchmark uses seed 42.

How I Built It

FrostSprout uses a deliberately lightweight architecture:

• Backend: FastAPI
• Frontend: Vanilla HTML, CSS, and JavaScript
• Tabular ML: TabPFN with a scikit-learn Random Forest fallback
• Local language model: Gemma 3 through Ollama
• Weather: Open-Meteo
• Audio: Browser-native Web Speech API

No API keys are required for the application's documented local workflow, although downloading model weights or obtaining model access may require additional setup.

The Architecture

The application follows a simple pipeline:

Weather and microclimate features → Frost-risk prediction → AI-generated garden guide → Audio and printable field card → Outdoor action

Each component has a defined responsibility.

The prediction layer handles numerical inputs. The language model turns the resulting metrics into understandable instructions. The interface then makes those instructions usable away from the screen.

This separation also makes it easier to replace individual components without redesigning the entire application.

TabPFN: The Prediction Layer

I integrated Prior Labs' TabPFN through backend/tabpfn_engine.py for tabular prediction tasks.

When the required model weights and authentication are unavailable, the application falls back to a scikit-learn RandomForestClassifier.

Importantly, the active model is reported rather than silently substituted. A fallback is a fallback, not a successful TabPFN run.

Verification status: TabPFN is not verified in my environment because model access failed with TabPFNLicenseError. I therefore do not claim that the TabPFN integration has been successfully benchmarked.

Gemma 3: Turning Predictions into Practical Advice

The language-model integration lives in backend/gemma_engine.py.

Gemma 3 runs locally through Ollama and converts numerical predictions into a three-step outdoor action guide, sensory observations, and companion-planting notes.

The application identifies the response source as gemma3 via Ollama when that path is used. If Ollama is unavailable, a deterministic template provides a fallback and reports offline template.

This is important because an application should not pretend that a language model generated a response when it actually used a predefined template.

Live Weather Without an API Key

Open-Meteo supplies the available live weather data.

However, not every feature is a live observation. Soil temperature, atmospheric pressure, and the seven-day rolling minimum currently use documented defaults.

These limitations matter: real weather inputs do not automatically make every prediction scientifically validated.

FrostSprout is an experimental garden assistant, not a certified agricultural forecasting system. Its risk estimates should be treated as decision support rather than a guarantee that frost will or will not occur.

Benchmark Results: What the Numbers Actually Mean

I benchmarked the prediction models using 800 synthetic samples, with a 75/25 train-test split.

Model	ROC-AUC
Random Forest	0.9987
XGBoost	0.9986
TabPFN	Not verified

These numbers look impressive, but there is an important caveat.

The synthetic labels are generated using the same underlying formula that creates the dataset. Consequently, the models can learn that formula and achieve near-perfect scores without demonstrating equivalent accuracy on real-world weather observations.

I report these results as a reproducible synthetic-data benchmark, not evidence of 99.87% real-world frost prediction accuracy.

The next meaningful evaluation step is testing against independently collected weather-station observations and verified frost outcomes.

Why Open Innovation Matters

Open-source AI isn't just a technology choice for FrostSprout. It determines who can run it, inspect it, and adapt it.

Privacy and Local Inference

Gemma 3 runs on the gardener's own machine through Ollama. The garden-guide generation step does not need a hosted language-model API.

This reduces dependence on external AI services, avoids per-request model API charges, and allows the core language-model workflow to run locally once the model is installed.

The application still retrieves weather from Open-Meteo, so the complete workflow is not fully offline.

Freedom to Inspect and Replace Components

The prediction engine, language model, prompts, crop guidance, and fallback logic can be inspected and modified.

Gardeners and developers can adapt the application to local crops, replace models, and eventually train against regional weather-station data.

Graceful Degradation

Local model inference is not always available. Hardware may be limited, weights may be inaccessible, and a service may fail.

FrostSprout is designed to expose these limitations and fall back to deterministic guidance rather than making unsupported claims about which model answered.

Transparency Over Artificial Confidence

Open tooling also made it possible to expose a limitation that would otherwise be easy to hide: my TabPFN integration remains unverified, and my current benchmark is based on synthetic data.

For a project that influences physical decisions, being clear about uncertainty is more valuable than presenting impressive numbers without context.

What I Learned

Building FrostSprout reinforced three lessons.

First, AI is most useful when it changes an action. A prediction is only the beginning. The real challenge is converting it into a decision someone can understand and carry out.

Second, graceful fallbacks are part of product design. A local model that sometimes fails needs an honest, useful alternative.

Third, reproducibility and honesty belong in the same README. Benchmarks should explain their dataset, assumptions, limitations, and verification status—not just display a score.

What's Next?

The next steps are to:

• Validate predictions against real weather-station data.
• Verify TabPFN inference in a supported environment.
• Improve regional crop guidance and document its sources.
• Add more robust historical observations and uncertainty reporting.
• Test the complete audio-first workflow outdoors with real gardeners.

I also want to test FrostSprout during an actual cold night, document what worked, and improve the field guide using those observations.

My Agent Session

Optional: Add a DevRelay agent-session link here.

Prize Categories

• Best Use of TabPFN — Prior Labs: Tabular prediction integration with an explicitly reported Random Forest fallback. TabPFN execution remains unverified.
• Best Use of Gemma — Google: Local Gemma 3 inference through Ollama for generating the outdoor action guide.

Final Thoughts

The best AI experience isn't necessarily the one that keeps you chatting for another ten minutes.

Sometimes it is the one that checks the weather, gives you three useful instructions, reads them aloud, and lets you close your laptop.

FrostSprout is my attempt to build that kind of experience.

Less scrolling. More soil under your fingernails. More time outside.

If you garden in a different climate, I'd love to hear what crops, frost conditions, or local observations you'd want FrostSprout to support.

Thanks for reading!