TouchGrass — AI That Gets You Off Your Screen

Sachchit — Mon, 12 Oct 2026 06:25:37 +0000

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

Built with Gemma by Google · Powered by Hugging Face · Deployed on Render · Open source on GitHub

What if AI didn't try to keep you online, but helped you step away?

Introducing TouchGrass — a lightweight, AI-powered micro-mission generator designed to turn spare time into real-world action.

Instead of another productivity dashboard, endless feed, or chatbot conversation, TouchGrass gives you one simple thing to do offline.

Try it live: https://t0uchgrass.onrender.com/

Source code: https://github.com/SachchitNesarikar/hacktober-26

The problem

We use technology to learn, build, work, and organize our lives. But sometimes, we get stuck consuming more content instead of acting on what matters.

I wanted to experiment with a different kind of AI product: one that helps you spend less time interacting with the product itself.

Meet TouchGrass

Choose one of three focuses:

Move: Take a walk, stretch gently, or change your surroundings.
Learn: Solve a problem on paper, read something meaningful, or explain a concept from memory.
Explore: Discover a new route, notice details around you, or make something by hand.

Choose whether you have 5, 15, or 30 minutes, optionally add a personal goal, and generate a micro-mission tailored to your situation.

Complete it, record a small reflection, and build a history of your wins — without needing to create an account.

The technology behind it

Gemma + Hugging Face

TouchGrass uses Google's Gemma 3 4B Instruct through Hugging Face's inference API to generate personalized, structured missions. The model receives the selected focus, available time, and optional personal goal, then returns a concise mission.

Render

The application is deployed as a Node.js web service on Render, serving the frontend and handling API requests. Model credentials stay in server-side environment variables rather than being exposed in browser code.

GitHub

The project is open source, with the implementation available for others to inspect, learn from, and extend.

Resilient by design

If inference is unavailable or the model returns an unusable response, TouchGrass can fall back to a curated library of missions. The core experience doesn't have to disappear just because an external AI service fails.

What makes it different?

Most AI products encourage you to ask another question, generate another response, or stay for another session.

TouchGrass explores the opposite approach:

Generate one useful idea. Take it into the real world. Close the tab.

It's a small experiment in making AI useful beyond the screen, with lightweight personalization and a deliberately simple interface.

What's next?

I'd love to explore knowledge-graph-based personalization, where interests, learning goals, and completed missions connect to produce more relevant suggestions over time — without requiring a complicated user profile.

Other possibilities include better mission-quality evaluation, more personalized recommendations, and measuring whether people actually complete the activities.

Try it. Build on it. Touch grass.

Live app: https://t0uchgrass.onrender.com/

GitHub repository: https://github.com/SachchitNesarikar/hacktober-26

Built as an open-AI experiment with Gemma, Hugging Face, Render, and GitHub.

The goal isn't to keep you here longer.

It's to help you find something worth doing out there.

I Built a Memory for My Friend

Sachchit — Mon, 05 Oct 2026 06:56:14 +0000

I was excited for the HacktoberFest Weekend Challenge, but there was one problem: I didn't have a friend to build for.

So I messaged my GPT for some good projects. I picked one, developed the idea with GPT, and then passed it over to Claude to actually build. A few prompts later, broke me hit the free-tier rate limit.

And suddenly, my "friend" couldn't continue. If I switched to another AI, I had to explain everything again: what we were building, why we made certain decisions, what we'd already tried, what had failed, and what I had explicitly asked it not to change. And when Claude became available again, I'd have to bring all of that context back.

I didn't need another AI.
I needed my AI friend to remember.

So I built Baton.

What I lost when the chat ended

I wasn't really losing a conversation. I was losing the project's state:

Decisions, and why — why we chose one approach over another
Dead ends — approaches we'd already tried and abandoned
Rules — constraints and conventions that shouldn't be changed
The half-finished task — and the bug I'd deliberately postponed

A new assistant doesn't know any of that.Pasting the entire transcript is slow and noisy. The new AI can cheerfully retry the failed idea, or "improve" the one thing I explicitly said to leave alone. Existing tools mostly move the transcript between assistants.

I wanted to move the state.

The idea

conversation
      ↓
local open-weight model
      ↓
structured project state
      ↓
handoff for any AI

Baton reads a conversation and fills a fixed schema instead of producing another generic summary:

{
  "goal": "...",
  "architecture": [],
  "decisions": [{"what": "", "why": ""}],
  "constraints": [],
  "user_preferences": [],
  "files": [{"path": "", "note": ""}],
  "recent_changes": [],
  "failed_attempts": [{"what": "", "why_failed": ""}],
  "known_bugs": [],
  "open_tasks": [],
  "do_not_change": [],
  "current_state": "...",
  "next_action": "..."
}

The split between decisions, failed_attempts and do_not_change is the heart of it.

Those are exactly the things a new AI can get wrong if it only sees a transcript. If a later message reverses an earlier decision, only the latest truth is kept. Baton then renders a handoff tuned for the target: XML sections for Claude, Markdown for Gemini and GPT, a compact format for small local models, or an AGENTS.md.

Every handoff ends with rules for the receiving AI:

Treat do_not_change as binding.
Don't repeat failed attempts.
Ask instead of guessing.

The goal isn't to make another summary. It's to make the next AI feel like it was there.

Why open-weight and local is the point

Your project history contains your architecture, your mistakes, and sometimes your secrets. It seems wrong to send that to yet another service just to keep your own context.

So Baton is designed around local extraction using an open-weight model:

Default: Gemma 4 E4B (Q4_K_M) through llama.cpp, downloaded from Hugging Face on first start.
Ollama, LM Studio, llamafile or any OpenAI-compatible server can also be used.
The model is instructed to produce the JSON schema, and the output is repaired and validated before reaching the UI.
Long chats are processed in chunks, with the running state fed back into subsequent extraction.

A hosted open-weight API is supported too, but the trade-off is simple: it stops being local-first.

Multi-agent mode for small models

A 4B model asked to fill 13 fields at once can miss things. So Baton has an optional multi-agent mode: four specialists each own a subset of the fields:

Archivist
Rules Keeper
Decision Analyst
Work Tracker

A Reconciler then fixes misfiled and duplicate items. There are also two safeguards:

If the Reconciler drops more than 30% of items, its output is discarded.
A deterministic check removes any filename that never appears in the conversation or git history.

You can also assign larger models to individual jobs using BATON_AGENT_MODELS.

[ADD YOUR ACTUAL EVALUATION RESULT HERE.]

Using it

Run bash scripts/run.sh to start llama.cpp, wait for the model, and open Baton. Docker is also supported with docker compose up -d --build.
Paste a conversation, or capture it with the browser extension.
Inspect the memory panel: decisions, constraints, failed attempts, do-not-change rules and open tasks.
Pick a target and generate the handoff.
Paste it into a fresh AI conversation and ask what the next task is and what must not be changed.

There's also Git awareness: point Baton at a local repository and recent commits and uncommitted changes can be included, so "recent changes" can come from repository facts rather than memory.

What's inside

Baton is intentionally small:

Plain Python with no pip dependencies
One static HTML page
A Manifest V3 browser extension
Support for Claude, ChatGPT and Gemini
24 tests against mock model servers
MIT licensed

Originality and credit

The space already has good tools.

Context-Bridge, for example, compresses transcripts into structured blocks through cloud providers. Other tools move raw sessions between coding agents or summarize conversations using your own API key.

Baton shares the broad problem, but not their code.

It's an independent implementation, and NOTICE.md lists related projects.

What I find most interesting about Baton's approach is the combination of:

the decision / failed-attempt / do-not-change split
local-first extraction
grounding checks against the conversation and git history

Honest limitations

I built Baton because I needed it, but that doesn't mean every part of it is solved.

I haven't run a rigorous benchmark across models; scripts/eval_models.py provides a rough keyword-overlap score rather than a full extraction-quality benchmark.
The browser extension's page selectors are fragile and will need maintenance when the target sites change.
The hosted demo is static and loads a reference state. Live analysis requires a local model.
Small models still miss items. The memory panel should be checked before handing the state to another AI.

What's next

This is only the beginning.

I'd like to add:

Importers for Claude Code and Codex session files
In-browser inference with WebGPU, so there is no local server at all
A verification step where the receiving AI restates the recovered state for the user to confirm
Better evaluation of extraction quality across different model sizes

And maybe, by the end of this challenge, my AI friends won't need me to introduce them to the project every time we switch between them. For now, Baton is my attempt to make project context portable.

Try it

Repo: : https://github.com/SachchitNesarikar/hacktober-26

DEV Community: Sachchit