TouchGrass AI 🌿 — Less Screen. More World!

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

What I Built

What if AI encouraged us to spend less time online and more time experiencing the real world?

That question inspired me to build TouchGrass AI — an AI-powered outdoor mission generator designed to help people take breaks from their screens and reconnect with the world around them.

As students and developers, we can easily spend hours sitting in front of our laptops. Between coding, studying, debugging, and scrolling, sometimes we need a little push to step outside.

Instead of building another AI tool that keeps users engaged with a screen, I wanted to explore a different idea: using AI to help people step away from technology.

TouchGrass AI turns the simple intention of going outside into a personalised, achievable mission.

Users can customise their experience based on:

• ⏱️ Time: How long they want to spend outdoors.
• ⚡ Energy: How energetic they feel.
• 🌿 Interests: What kind of activities they enjoy.
• 🧍 Company: Whether they want to go solo or spend time with others.

The application uses these preferences to generate an outdoor mission. Users can then complete the activity and track their progress through the app's gamified experience.

The idea is simple: make taking a break feel less like another task and more like a small adventure.

Who is it for?

TouchGrass AI is for students, developers, remote workers, and anyone who spends a lot of time online and wants a gentle reminder to move, explore, and experience life beyond a screen.

My guiding philosophy:

Less screen. More world. 🍃

Demo

🌐 Live application:

touchgrass-ai-fq0a.onrender.com

🎥 Video demonstration:

Code

💻 GitHub repository:

rasikachavan13 / -TouchGrass-AI

**TouchGrass AI — AI that gives you a reason to leave the screen.** A local-first AI companion that creates personalized, screen-free outdoor missions based on your time, energy, interests, and company. Built with React, Express, Ollama, Gemma 3, Backboard, and Tinker.

🌱 TouchGrass AI

AI that gives you a reason to leave the screen.

TouchGrass AI is a local-first outdoor activity companion that uses AI to generate personalized, real-world missions based on your available time, energy, interests, and company.

Instead of keeping users inside another chatbot, TouchGrass AI encourages them to go outside, move, observe, explore, and interact with the physical world.

🌐 Live Demo: https://touchgrass-ai-fq0a.onrender.com

✨ What It Does

Tell TouchGrass AI:

• ⏱️ How much time you have
• ⚡ Your current energy level
• 🌿 What interests you
• 👥 Whether you're going alone or with others

The AI generates an outdoor mission tailored to your preferences.

Each mission includes:

• A memorable title
• A short description

• Three practical steps

• Suggested items to bring

• A real-world observation challenge

Example Mission

Quiet Campus Explorer

Turn an ordinary walk into a deliberate exploration by observing environmental details, noticing patterns in nature, and experiencing your surroundings…

View on GitHub

The project is publicly available, and the repository contains the application code and project documentation.

How I Built It

TouchGrass AI evolved from a simple concept into a full-stack application involving frontend development, backend APIs, AI integration, memory experiments, local inference, and cloud deployment.

The Technology Stack

• React & Vite: Building the interactive frontend and build tooling.
• CSS: Styling the application and its responsive, nature-inspired interface.
• Node.js & Express.js: Building the backend and API endpoints.
• Gemma 3 4B & Ollama: An open-weight language model used in local AI experimentation, run locally.
• Backboard: Experimenting with AI memory and saving user preferences.

• Gemini API: Exploring hosted AI generation for the production integration.
• Tinker: Exploring the model fine-tuning and evaluation workflow separately from the main application.

• Render: Deploying the web application and backend.

• localStorage: Persisting supported user progress in the browser.

1. Frontend: Making the experience approachable

I used React and Vite to build the user interface, with CSS to create a minimal, nature-inspired visual identity. The interface lets users select their preferences, request a mission, and interact with their progress without demanding constant attention like a productivity dashboard.

2. Backend: Connecting the application to AI

The Node.js and Express backend handles requests from the frontend and provides the API layer for mission generation.

The intended workflow is:

1. The user selects their preferences.
2. The frontend sends these preferences to the backend.
3. The backend communicates with the configured model provider.
4. The generated mission is returned to the frontend.

Building this flow taught me that an AI application is not just a single prompt; the frontend, backend, model runtime, API configuration, and error handling must all work together.

3. Open-weight AI: Gemma 3 4B and Ollama

One of the most educational parts of this project was experimenting with Gemma 3 4B through Ollama. Running the model locally helped me understand how open-weight models can be integrated without relying exclusively on a hosted inference API.

Debugging local model configuration and backend integration errors helped me understand the deeper connection between model runtimes and Express APIs.

4. Backboard: Exploring AI memory

I also experimented with Backboard to explore how an AI application could retain useful context about a user. In the backend, I implemented preference-saving functionality that records details such as selected time, energy, interests, and company preferences.

5. Tinker & Gemini API

Alongside local Gemma and Ollama experiments, I worked on a Gemini API integration for hosted AI generation and explored Tinker separately for model fine-tuning and evaluation workflows.

6. Render Deployment

I deployed the application using Render, making the project accessible through a public URL. Deployment introduced a great lesson: a site loading successfully doesn't mean every backend integration works out-of-the-box; AI generation must always be tested end-to-end in production.

Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to experiment, learn, adapt, and build beyond the boundaries of a single closed service. Working with open-source tools and open-weight models provides:

• Learning through implementation: Seeing how runtimes, backends, and frontends communicate.
• Flexibility: Choosing between local inference and hosted APIs based on the problem.
• Accessibility: Creating opportunities for students and independent developers to build practical AI projects.

✨ What It Does

Tell TouchGrass AI:

• ⏱️ How much time do you have?
• ⚡ Your current energy level
• 🌿 What interests you
• 👥 Whether you're going alone or with others

The AI generates an outdoor mission tailored to your preferences.

Each mission includes:

• A memorable title
• A short description

• Three practical steps

• Suggested items to bring

• A real-world observation challenge

Example Mission

Quiet Campus Explorer

Turn an ordinary walk into a deliberate exploration by observing environmental details, noticing patterns in nature, and experiencing your surroundings without digital distractions.

🌿 Core Features

Feature	Description
Personalised missions	Generate outdoor activities from user-selected preferences.
Local AI inference	Run missions locally using Ollama and Gemma 3 4B.
Cloud AI generation	Use Gemini through the deployed backend.
Memory-powered personalisation	Backboard stores and retrieves outdoor preference memories.
Outside Mode	A distraction-free experience designed around completing the mission.
Mission history	Review previously generated missions.
TouchGrass Score	Earn points for completing missions.
Streaks and milestones	Track progress and encourage consistent outdoor activity.
Local persistence	Save progress in the browser using localStorage.

🧠 AI Architecture

Local Development

The local setup supports inference on the user's machine after the required model has been downloaded. Mission history and score are stored separately in browser localStorage.

Production Deployment

The deployed application uses Gemini for cloud-based mission generation. The local Ollama setup is used for local development and testing; it is not automatically available to the cloud deployment.

🛠️ Tech Stack

Component	Technology
Frontend	React, Vite, CSS
Backend	Node.js, Express
Local inference	Ollama
Local model	Gemma 3 4B
Cloud inference	Gemini API
Preference memory	Backboard
Fine-tuning experiment	Tinker, LoRA
Deployment	Render
Browser persistence	localStorage

🧠 Tinker Fine-Tuning Experiment

TouchGrass AI also includes a domain-specific fine-tuning experiment using Tinker.

Fine-Tuning Setup

• Base model: Qwen/Qwen3.5-4B
• Fine-tuning method: LoRA
• LoRA rank: 16
• Training examples: 8
• Training steps: 10
• Checkpoint: touchgrass-v1
• Checkpoint type: Sampler weights

The training examples were designed to encourage the behavior required by TouchGrass AI:

• Screen-free outdoor activities
• Safe, practical real-world experiences
• Minimal equipment requirements
• Specific, actionable instructions
• Physical-world observation challenges
• No unnecessary dependence on apps, internet access, photos, or digital navigation

Why Fine-Tune?

A general-purpose model can suggest outdoor activities, but TouchGrass AI has a more specific goal: generate practical missions that encourage users to disconnect from their screens.

The experiment explored whether a small, domain-specific dataset could encourage more consistent adherence to these requirements.

AI should create a reason to leave the screen, not another reason to stay on it.

Evaluation and Limitations

The fine-tuned model was compared with base-model generations using the same prompts.

In the observed examples, the fine-tuned model showed stronger adherence to some screen-free and outdoor-activity constraints. However, the results were not consistently better across every dimension, including creativity and specificity.

The experiment is preliminary. With only eight training examples and ten training steps, it does not establish a general performance improvement. A larger dataset, repeatable evaluation set, and quantitative measurements would be needed to support stronger conclusions.

The fine-tuned checkpoint is a separate experiment and is not the model currently serving missions in the live application.

🔓 Why Local-First and Open Innovation?

TouchGrass AI explores how locally run AI can support a more privacy-conscious, accessible experience.

• Local inference: Run the local version without sending mission prompts to a cloud AI provider.
• Privacy-conscious design: Keep local mission history and score in browser storage.
• Reduced API dependence: Local generation does not require a paid cloud inference request once the model is available.
• Model experimentation: Explore different models and specialized fine-tuning approaches.
• Practical AI: Use AI to encourage real-world activity rather than maximize screen time.

Ollama provides the local inference tooling, while Gemma 3 is an open-weight model distributed under its applicable license. These are distinct from the separate cloud Gemini integration.

Run Locally

Prerequisites

• Node.js and npm
• Ollama
• Git

1. Clone the repository

git clone https://github.com/rasikachavan13/-TouchGrass-AI.git
cd -TouchGrass-AI

2. Download the local model

ollama pull gemma3:4b

Make sure Ollama is running before generating missions locally.

3. Configure the backend

cd backend
npm install

Create a .env file using .env.example as a reference.

Configure the local model and, if desired, your Backboard credentials:

PORT=5000
FRONTEND_URL=http://localhost:5173

OLLAMA_HOST=http://127.0.0.1:11434
OLLAMA_MODEL=gemma3:4b

BACKBOARD_API_KEY=
BACKBOARD_ASSISTANT_ID=

GEMINI_API_KEY=
GEMINI_MODEL=gemini-3.8-flash

Start the backend:

npm start

4. Configure the frontend

Open a second terminal:

cd frontend
npm install

Create frontend/.env with:

VITE_API_URL=http://localhost:5000

Start the frontend:

npm run dev

Open the local URL printed by Vite, usually http://localhost:5173.

Prize Categories

My project explored open-weight AI through Gemma 3 4B and Ollama, and I used Render to host the application. I will only claim specific partner prize categories if the implementation meets their official requirements.

Final Thoughts

TouchGrass AI began with a small question: could technology help us become more intentional about using technology itself?

Not every experiment became part of the production application, and not every integration worked on the first try, but those challenges formed the core of the learning process.

What would you build if AI's purpose were to help people reconnect with the real world? Let me know in the comments below! 👇