TouchGrassAI : Turning Screen Time Into Outdoor Adventures With Local AI

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

Why I Built TouchGrassAI 🌿

We have plenty of apps competing for our attention. I wanted to build something that uses AI for a different purpose: helping people spend less time on their screens and more time in the real world.

That's the idea behind TouchGrassAI — a nature-inspired app that turns a simple choice, like taking a walk or going birdwatching, into a small outdoor adventure.

Instead of relying on a hosted AI API, TouchGrassAI uses the open-weight Qwen2.5 3B model through Ollama, running on the user's own machine.

The goal is simple: let AI help plan the adventure, then make the actual adventure happen away from the screen.

What I Built

TouchGrassAI lets you choose three things:

• Activity: Choose an outdoor activity, such as a nature walk or birdwatching.
• Duration: Decide how much time you have.
• Energy level: Match the mission to how active or relaxed you feel.

Based on those choices, the local AI generates an outdoor mission with actionable steps, a nature fact, and a safety tip.

The app also lets you check off individual steps, copy a mission, and mark an adventure as complete. Your completed-adventure count persists when you refresh the page.

The idea is to make going outside feel approachable. You don't need an elaborate itinerary or an entire free afternoon. Sometimes, a short walk with one small goal is enough to get started.

The Homepage

The Mission Experience

Demo

🎥 Video Demo: Watch TouchGrassAI in action

💻 Source Code: TouchGrassAI on GitHub

TouchGrassAI uses the open-weight Qwen2.5 3B model through Ollama to generate personalized outdoor missions locally. The demo showcases the application's workflow and nature-inspired experience.

The screenshots above show the actual application interface and mission experience.

The AI generation currently runs locally through Ollama. This is not a publicly hosted AI demo: to generate missions, users need to install Ollama and download the model on their own machines.

How I Built It

I built TouchGrassAI with a React and Vite frontend connected to a locally running Ollama instance.

The main components are:

• React: Manages the interface, activity preferences, loading states, mission steps, and completion count.
• Qwen2.5 3B: Generates missions based on the selected activity, duration, and energy level.
• Ollama: Runs the model locally and exposes an API that the frontend uses to request generations.
• React Markdown: Renders the model's response, with structured mission sections when the expected headings are present.
• CSS: Provides the responsive, nature-inspired interface, including accessible focus styles and reduced-motion support.

The generation flow is straightforward:

1. The user selects an activity, duration, and energy level.
2. The frontend sends a prompt to the local Ollama API.
3. Qwen2.5 3B generates a mission with steps, a nature fact, and a safety tip.
4. The app presents the result as a structured, interactive mission.
5. The user can complete the steps and mark the adventure as finished.

I also worked on making the application more reliable. It handles loading and error states separately, supports cancellation and retry, checks whether Ollama is available, and uses a timeout for slow model responses.

The completed-adventure count is stored locally in the browser. The application does not need to save full prompts to maintain that counter.

One important limitation is that the application depends on a local Ollama installation and a downloaded model. It is designed around local inference rather than a hosted AI service.

Why Does Open Innovation Matter?

For this project, open-weight AI is not just an extra feature. It is central to how the application works.

Using Qwen2.5 3B through Ollama means that mission generation can happen on the user's machine rather than requiring a request to a third-party hosted model API.

That brings several practical advantages:

• More control: Users can choose how and where they run the model.
• Local inference: The app sends generation requests to the local Ollama service instead of a remote AI provider.
• Model flexibility: The integration can be adapted to another compatible model in the future.
• Fewer external dependencies for inference: There is no need for a hosted model API key or per-request API billing for the current local setup.

There is a distinction worth making: running inference locally does not automatically make every part of an application completely offline. Initial model downloads require connectivity, and this frontend currently loads its typography from Google Fonts. Those are separate from the local AI inference itself.

I like that this approach gives the user more control over the AI component. It also made me think about AI less as a chatbot that keeps someone engaged and more as a tool that can help someone decide what to do next — then get out of the way.

What I Learned

Building TouchGrassAI pushed me to think beyond generating a response from a model.

A useful AI application also needs to handle slow responses, connection failures, unexpected output formats, cancellation, and the interface states that surround generation.

I also learned how much the presentation matters. A generated response is easier to use when its steps, facts, and safety advice are clearly separated instead of appearing as one long block of text.

Most importantly, this project reminded me that the best outcome of an AI interaction does not always need to happen on the screen.

Sometimes, the screen should help you decide what to do — and then let you go do it.

AI Tooling Usage Disclosure

I used ChatGPT to brainstorm and structure this article and refine its wording. I used Google Antigravity to assist with code improvements, debugging, and UI refinement. TouchGrassAI itself uses the open-weight Qwen2.5 3B model through Ollama to generate outdoor missions locally. I reviewed and tested the application's main features before submission.

What's Next?

I'd like to keep improving TouchGrassAI with more outdoor activities, better mission variety, and additional ways to make short adventures feel rewarding.

For now, the focus is on keeping the experience simple: choose an activity, generate a mission locally, and head outside.

If you try the project, I'd love to hear what kind of outdoor mission you'd want an AI to suggest.

Thanks for reading! 🌿