Shristi Sharma

Posted on Oct 10

🌼🍃Flâner: Small steps, Bigger days— Let the Ordinary Lead You Somewhere New.

#devchallenge #hf26challenge

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

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

What I Built

Flâner (to wander without hurry, and notice the little things along the way) is a gentle AI companion that helps you take one small step out of the house, then gets out of the way.

Most apps want more of your attention. Flâner is built to want less of it. You talk to it for about a minute, it hands you a small plan, and then it tells you to put your phone away.

Where the idea came from

The theme was Touch Grass, and the more I thought about it, the more it described something I see everywhere. Our homes are comfortable and our phones are endlessly interesting, so we stay in. Slowly we stop noticing what's outside: the street, the light, the small shop around the corner. And the less we go out, the less we explore.

People stay in for many different reasons. Some are simply comfortable. Some find going out a hassle. Some dislike it, and some feel uneasy about it. Whatever the reason, the hardest part is almost always the first step, and "go outside more" is too big and vague to act on.

What helps is a plan. A plan turns a vague wish into a short list, and ticking a box gives a small, real sense of achievement. So Flâner keeps the outing small enough to finish: a checklist for an outing. The reward comes from the real world, not from the app, which is why there are no points or streaks.

The second half of the idea is the reflection. When you come back, Flâner asks what you saw, enjoyed and noticed. Having to remember those details trains you to look for them next time. My hope is that, over time, your attention drifts from the phone to your surroundings.

How it works

Pick a door. I have somewhere to go (groceries, errands, college), I want to explore (a walk, your neighbourhood, some nature), or I need a little nudge (for when you feel stuck).
Get a plan. An open-weight model turns your task into a short, editable checklist: before leaving, getting there, the task itself, coming home. Groceries get your own shopping list word for word. Errands get "check opening hours" and "what to bring". Walks get optional "notice along the way" prompts.
Go. A calm "The world is waiting" screen. No chat, no GPS, no timer. The plan is already on your device as a checklist.
Look back. When you return, Flâner asks what you saw, enjoyed and noticed. Recalling small details is meant to build observation skills. A second model then writes a short, specific acknowledgement.

Who it's for: people who find the first step the hardest part (a grocery run they keep postponing, a walk they never start), and anyone who wants to notice more of the world around them. There are no XP, streaks or leaderboards, staying home is treated as okay, and partial progress counts.

I tried to design against the usual engagement loop. Reflection notes are only stored if you choose Save this moment, and the dashboard is a private record of getting out, not a score.

I took it outside

I needed groceries and had put it off for three days, half-tempted to just order online. I really didn't feel like going. Before leaving, I typed what I needed to buy into Flâner, so my plan already had my list in it. That helped more than I expected: at the shop I didn't have to stop and think about what I'd forgotten. I knew exactly what I was looking for and found the things faster.

The first steps in the checklist (freshen up, get dressed) were what got me moving. I had a bath, got dressed, went to the shop and came back feeling prepared and glad I'd gone. It was a small, ordinary errand, and that's the point. (I used a test account, which I've since deleted.)

Demo

Live app: https://flaner-twp3.onrender.com/

You need an internet connection to use it.

It runs on a free Render instance, so the first visit after a quiet period can take up to a minute to wake up. Sign up with any email to try it.

Code

View the code on GitHub

How I Built It

Stack: vanilla HTML/CSS/JS frontend (no framework, no build step), a Node and Express backend, Supabase for login and data. Everything is deployed as one web service on Render.

Browser ──► Express server ──► plan model       (open-weight gpt-oss-20b on Groq)
   │             │
   │             └──────────► reflection model  (swappable; Gemini in my demo)
   └── Supabase: login, profiles, saved outings (row-level security)

The open-source AI at the core

Plan model: openai/gpt-oss-20b, an open-weight model, served through Groq's OpenAI-compatible API. It does the main work. A system prompt tells it to return only JSON, and the server then extracts it, validates the shape, trims lengths and drops unknown fields. If the model fails, a built-in plan takes over, so the user never sees a broken screen.
Prompts as the "agent's behaviour." The rules live in two plain-text prompts in the repo: be specific to the task, never invent a park, shop, route or opening time, treat safety worries as real, and never shame. Changing how the companion behaves means editing text, not retraining.
Any model, three lines. The server talks to any OpenAI-compatible endpoint, so LLM_BASE_URL, LLM_API_KEY and LLM_MODEL switch between Groq, a local Ollama model, Hugging Face, DeepSeek and others.
A second model for the closing reflection. Each outing makes two AI calls. I split them across two providers so one provider's limits can never block the app. In my demo the reflection uses Gemini (gemini-3.5-flash-lite). That one is not open-weight. It only writes a few kind sentences, and REFLECT_PROVIDER=off removes it, or it can point at any open model.

LLM_MODEL=openai/gpt-oss-20b
REFLECT_MODEL=gemini-3.5-flash-lite

Things that went wrong, and what I did

Hugging Face returned HTTP 402 ("no remaining credits") when I first used it for the reflection. Because the model is a setting rather than hard-coded, I switched providers by changing configuration.
The bottom buttons and tab bar sat off-screen until you scrolled to the end of a page. A container's overflow:hidden stopped them pinning, and switching it to overflow:clip fixed it.

Limitations

Flâner needs an internet connection. Sign-in, building a plan, the reflection and saving all go through Supabase and the AI models, so the app does not work offline. The live demo also runs on a free Render instance that sleeps when it's quiet, so the first visit can be slow.
The model doesn't know where you are. It never names real places. You supply any you want to mention.
The reflection model isn't open-weight. Only the closing acknowledgement uses Gemini, and it can be switched off.

Privacy and your data

What	Where it goes	Kept?
Email and password	Supabase sign-in.	For your account
Name, step-size preference, optional "about me" note	Supabase	Until you delete it
A record of each finished outing: the type (e.g. "Got groceries"), how it felt, minutes outside, a place you name, and the date and time	Supabase, readable only by you	Yes. Saved when you finish (Done for today, Plan another outing or Save this moment)
Reflection notes (what you saw, enjoyed, noticed, expected, happened, remember)	Supabase, only if you tap "Save this moment"	Only if you save
What you type when building a plan or reflection (details, shopping items, notes)	Sent to the AI models (Groq for plans, Gemini for the closing reflection) to write the reply	Not saved by my server or in my database, except notes you choose to save
The plan itself (the checklist the AI writes)	On your own device only	Until you finish or clear it. It is not saved in my database

Outings you start but don't finish are never saved to the database.

Why Does Open Innovation Matter?

I'll be specific about what I did and didn't prove.

Swapping and control. When one provider stopped working, I changed configuration and carried on. The companion's behaviour lives in prompts in the repo that anyone can read and edit. With a single closed API, a pricing change or a limit would have stopped the whole product.
Privacy. What people write about why going out feels hard is personal, and many wouldn't want it sent to a company's server. Because the plan model is open-weight, the same code is designed to run it on the user's own machine through Ollama, so that text never has to leave their laptop. My live demo doesn't work that way: it uses Groq to host the open weights and a hosted Gemini model for the closing reflection, so text goes to those providers. I haven't run the fully local setup in production.
A plan that stays available. The generated checklist is kept on the user's device, so once it has loaded, it doesn't need another AI request to be viewed. The current app still needs an internet connection for sign-in and generating new plans; a fully offline version would need local model inference and offline data handling, which I haven't implemented yet.
Right-sized AI. Turning a short description into a checklist doesn't need the biggest model. A 20B open-weight model is enough, and that keeps it cheap and laptop-sized.
Cost. There's no licence fee for the open model. Hosting and API calls still cost money beyond free tiers.
What I didn't do. I haven't benchmarked this against a closed model, so I can't claim it beats one on quality. I also haven't fine-tuned anything. The "what I feared, what happened" reflections could become a training set one day, but only with consent.