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

Touch Grass Garden: an offline garden planner with a local LLM that gets you outside 🌱

TL;DR: Tell it your city, and it tells you exactly what to start, sow, transplant, or plant this week. A 1 GB open-weight model runs entirely on my laptop and writes the weekly briefing. No API keys, no cloud, and no internet connection required. The screen is the shortest part of the experience: check the plan, close the laptop, and go touch grass. 🌱

🔗 Repository: https://github.com/AdityaAneNenu/touchgrass-garden

⚖️ License: MIT

🤖 Model: Qwen2.5-1.5B-Instruct, Apache-2.0

What I Built

Touch Grass Garden is an offline garden planner designed to get people away from their screens and into the real world.

Instead of constantly searching the internet for gardening advice, you give the CLI your city and it calculates what you should be doing in your garden this week.

The project has two layers:

1. Deterministic Gardening Planner

The core planner uses only Python's standard library and bundled JSON data.

It includes:

• Average frost dates for 50 US metros
• Planting rules for 30 crops
• Frost-date-based calculations
• Planting windows
• Automatic year rollover
• Priority ordering for tasks

Every gardening action is calculated from actual planting rules.

For example:

Tomatoes: start indoors 6 weeks before the last frost.

A task becomes due when its target date falls within ±10 days of today.

This means the core planner works even with zero AI and zero internet access.

2. Local AI Garden Coach

After the deterministic planner calculates the gardening tasks, Qwen2.5-1.5B-Instruct turns those verified facts into a short weekly briefing.

The model runs locally using:

• llama-cpp-python
• GGUF Q4_K_M quantization
• CPU-only inference

The model does not decide which crops should be planted or change any planting dates.

Instead:

User's City ↓ Frost Dates + Crop Rules ↓ Deterministic Gardening Planner ↓ Verified Gardening Tasks ↓ Local Qwen2.5-1.5B ↓ Weekly Briefing 

This separation keeps the important gardening calculations deterministic while still using AI to make the information more useful and engaging.

The project provides seven main commands:

• plan — Generate a gardening plan without AI
• brief — Generate an AI-powered weekly briefing
• ask — Ask the local garden coach a question
• chat — Start an interactive gardening conversation
• config — Configure your city or custom frost dates
• cities — List supported cities
• doctor — Check installation and model configuration

The planner also supports:

--json --ics 

for exporting plans as structured JSON or calendar events with day-before reminders.

The idea behind the project is simple:

1. Run the planner. 2. Check what needs to be done. 3. Close the laptop. 4. Go outside. 5. Actually garden. 

The screen should help you get outside — not become the activity itself.

Real Local Output

This was tested on my 8 GB RAM, GPU-less Windows laptop.

> touchgrass brief denver --date 2026-03-15 DO THIS WEEK (9 jobs, in priority order): + Start indoors Peppers Mar 10 (5 day(s) ago) + Start indoors Tomatoes Mar 24 (in 9 days) ... WEEKLY BRIEFING (local Qwen2.5-1.5B, running on this machine) ...model-generated encouragement and priority list... [qwen2.5-1.5b-instruct-q4_k_m.gguf loaded in 7.3s, generated at 6.8 tok/s, offline] 

It also works for fall gardening. For example, an October plan for Portland can correctly identify tasks such as planting tulips and garlic.

The complete unedited command demonstrations are available in DEMO.md.

Demo

Repository

https://github.com/AdityaAneNenu/touchgrass-garden

Command Demo

> touchgrass brief denver --date 2026-03-15 DO THIS WEEK (9 jobs, in priority order): + Start indoors Peppers + Start indoors Tomatoes ... WEEKLY BRIEFING (local Qwen2.5-1.5B, running on this machine) ...model-generated briefing... [qwen2.5-1.5b-instruct-q4_k_m.gguf loaded in 7.3s, generated at 6.8 tok/s, offline] 

📸 Project screenshot / short demo video:

[ADD YOUR SCREENSHOT OR SHORT DEMO VIDEO HERE]

Full Demonstration

The complete output for the project's commands is available in:

DEMO.md

Code

The complete source code is available on GitHub:

https://github.com/AdityaAneNenu/touchgrass-garden

The repository contains:

• Source code
• Gardening data
• CLI implementation
• AI integration
• Model download scripts
• Tests
• Documentation
• Demo transcripts
• CI configuration

The project is released under the MIT License.

The Qwen model weights used by the project are released under the Apache-2.0 license.

How I Built It

I built Touch Grass Garden using Python with a deliberate separation between deterministic logic and generative AI.

Technology Stack

Deterministic Core

The deterministic layer contains the actual gardening logic.

It takes:

City + Frost Dates + Crop Rules + Current Date 

and produces:

Planting Tasks + Task Dates + Priority + Season 

Because this layer is deterministic, the application does not depend on an AI model for the correctness of the gardening schedule.

The model cannot accidentally invent a planting date because the dates are calculated before the model is called.

Local AI Layer

The local LLM receives the deterministic gardening plan as grounded context.

A fixed system prompt defines the behavior of Sprout, the garden coach.

The model then generates:

• Weekly gardening briefings
• Explanations
• Answers to follow-up questions
• Encouragement to complete outdoor tasks

The output is limited so that the briefing stays short and actionable.

The model runs completely locally.

There is no:

API key Cloud inference Remote server External gardening API 

required for normal operation.

Model

The project uses:

Qwen2.5-1.5B-Instruct

with:

• GGUF format
• Q4_K_M quantization
• Approximately 1 GB model size
• CPU-only local inference

On the test laptop, the model loaded in approximately 7.3 seconds and generated at approximately 6.8 tokens/second.

Testing

The deterministic test suite currently contains 61 tests covering:

• Frost-date calculations
• Planting windows
• Year rollover
• Plan generation
• Calendar export
• JSON export
• CLI behavior
• Other core functionality

The test suite does not require the model file.

This makes CI faster, cheaper, and more reliable while keeping the AI layer separate from the core correctness tests.

The repository also uses CI across multiple Python versions and operating systems.

Why Does Open Innovation Matter?

Open innovation was important because the goal of this project was not simply to add an AI chatbot to a gardening application.

The goal was to build something that could remain useful without the cloud.

The gardening knowledge itself is bundled with the application as local data.

The AI model is also available locally.

That combination enables something that is difficult to achieve with a traditional closed API approach:

The entire experience can continue working after disconnecting from the internet.

The user's city, gardening questions, and generated conversations do not need to leave the device.

Open-weight models also make experimentation possible.

Because the application accepts GGUF models, users can potentially experiment with:

• Smaller models for faster inference
• Larger models for higher-quality responses
• Different quantization levels
• Future fine-tuned models
• Other compatible open-weight models

This keeps the application architecture flexible instead of tying it to a single hosted AI provider.

Another major benefit is cost.

After installation, the application can run locally on a low-end laptop without recurring inference charges.

That makes local AI practical for a much wider range of users and projects.

Most importantly, open innovation makes the philosophy of the project possible:

AI should help reduce screen time, not create more of it.

The deterministic planner gives the system reliable facts.

The local model turns those facts into a useful briefing.

Then the user closes the laptop and goes outside.

My Agent Session

[ADD YOUR DEVRELAY AGENT SESSION HERE IF AVAILABLE]

Prize Categories

• Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
• Open Source
• AI

I Took It Outside 🌿

[ADD YOUR REAL-WORLD FIELD NOTES HERE]

For example:

I ran the October gardening plan for my city and used the recommendations to decide what needed attention that week. After checking the generated tasks, I closed my laptop and actually went outside to work on the garden. One thing the application got right was the timing of the seasonal task, while the real-world conditions in the garden reminded me that local soil and weather can still differ from an average schedule. That was exactly the point of building this project: use the computer to create a plan, then spend the real time outdoors.

What I'd Improve

There are still several things I would like to improve.

The bundled dataset currently covers 50 US metros, although users outside those locations can configure their own frost dates with:

touchgrass config set-frost 

The 1.5B model can occasionally drift from the prompt, which is another reason the application keeps the actual planting calculations outside the LLM.

Harvest forecasts are also approximate and should be treated as estimates rather than predictions.

Future improvements could include:

• Southern Hemisphere support
• More global city data
• Persistent chat sessions
• More crop varieties
• Better local-weather integration
• More precise gardening recommendations

Try It

Install

uv sync 

Download the Local Model

powershell -ExecutionPolicy Bypass -File scripts/download-model.ps1 

The model download is approximately 1 GB, resumable, and SHA-256 verified.

Verify the Installation

uv run touchgrass doctor 

Configure Your City

uv run touchgrass config set-city denver 

Generate a Weekly Briefing

uv run touchgrass brief 

Or Generate a Deterministic Plan Without AI

uv run touchgrass plan 

The deterministic planner works without loading the local model.

Final Thoughts

Touch Grass Garden started with a simple question:

What if AI could help us spend less time using computers instead of finding new reasons to use them?

The answer was to make the AI layer intentionally small.

The computer calculates the gardening schedule.

The local model explains it.

Then the user goes outside.

That's the entire idea behind Touch Grass Garden. 🌱

🔗 GitHub: https://github.com/AdityaAneNenu/touchgrass-garden

🌿 Check the plan. Close the laptop. Touch grass.