This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
What I Built
Nice Out answers one question: when should I go outside today?
Weather apps give everyone the same numbers. But 31° at 6 pm is a great run for one person and a sweaty mess for another, and the app can't tell which one you are. So most days you check the forecast, can't decide, and stay in.
Nice Out learns what "nice out" means to you:
- Pick your area. No account. Your location is rounded to about 5 km.
- Rate 14 real hours from your past week. "Would you have gone out?" Yes or no. The hours are picked to cover cool, mild and hot, at different times of day.
- Get one answer. TabPFN learns your line from those few rows and scores every hour of the next 36. The home screen shows the next window ("Go out at 8:30 pm, until 11:30 pm, 95% chance you'll enjoy it") and the two or three conditions behind it, in plain words.
- Go outside, then tap Great, Fine or Bad. Each outing becomes a new training row, so it gets better the more you go out.
- Ask about a plan. "When can I do a 1-hour run tomorrow?" A Mastra agent reads your personal forecast and answers in plain text.
The goal is to spend ten seconds in the app and then close it.
Demo
Live: https://nice-out.vercel.app (works on a phone, no sign-up)
I took it outside
I set it up for my own area on Tuesday morning. Rating the 14 hours took about a minute, and my own answers taught me more than I expected.
I said no to every mid-afternoon hour it showed me: 3:30 pm on three different days, at feels-like 29°, 33° and 35°. But I said yes to 10:30 am at 32° and 33°, and yes to 10:30 pm at 28° with 88% humidity. So for me it isn't really about the temperature. Afternoons are out, and mornings and evenings are fine even when they're just as warm.
A fixed "feels like 16–30°" rule gets that wrong both ways: it would send me out at 3:30 pm on a 29° day and keep me in at 10:30 am on a 33° one.
TabPFN picked it up from those 14 rows. Its first forecast for me gave 1:30 to 4:30 pm only 42–50%, then jumped to 72% at 5:30 pm and stayed above 80% through the evening. That's my week, pretty much exactly.
Code
Sarcastic-Soul
/
nice-out
Learns what nice weather means to you with TabPFN, then tells you the next window to go outside.
Nice Out
Weather apps tell everyone the same thing. Nice Out learns what "nice out" means to you, then tells you the next window to go outside, so you can close the app and go.
You rate about 14 real hours from your past week ("would you have gone out?"). TabPFN, an open tabular foundation model, learns your line from those few rows with no training step, and scores every hour of the next 36. The home screen shows one answer: the next window, how likely you are to enjoy it, and the two or three conditions that matter. Every time you come back from outside you tap Great, Fine or Bad, and that becomes a new training row.
Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 1 (theme: Touch Grass).
What it does
- Quick start. 14 past hours, picked to cover cool, mild and hot hours…
MIT licensed. The README has the architecture diagram, setup steps, and how to run TabPFN on your own machine instead of the hosted API.
How I Built It
flowchart LR
B[Browser<br/>random id in localStorage] -->|ratings, outings| API[Next.js route handlers]
API --> OM[Open-Meteo<br/>forecast + air quality]
OM -->|hourly rows| T[(Tiger Cloud<br/>TimescaleDB hypertable)]
API -->|your ratings as a table| P[TabPFN-3.5<br/>Prior Labs API]
P -->|chance per hour| API
API -->|cached per hour| T
B -->|chat| M[Mastra agent<br/>gpt-oss-120b on Groq]
M -->|tools: forecast, history, log outing| API
M -->|memory| TTabPFN does the predicting. This is a small-data problem: one person, a dozen or so rated hours to start. Training a normal model on 14 rows doesn't work well, and asking people to rate 200 hours first means nobody finishes setup. TabPFN is a foundation model for tables: it was pre-trained to handle small tables in a single forward pass, so there's no training step and it copes with very few rows. Each rating stores the conditions at that hour as 11 features (local hour, feels-like, temperature, humidity, rain chance, rain amount, cloud, wind, UV, daylight, PM2.5). The app sends your rows plus the next 36 hours to TabPFN-3.5 through the Prior Labs REST API and gets back a chance per hour. Hours at 60% or more become windows; night hours are never suggested. Results are cached per hour and per rating count, so each person costs at most one prediction an hour (about 5 s fresh, under half a second cached).
Honest scoring. When you log an outing, the app also stores the chance it showed for that hour before you went. After 5 outings, it shows how many it called right, next to a generic "feels like 16–30°, dry, clean air" rule. I first tried a holdout on the quick-start answers, but splitting 14 rows in two is mostly noise, so the score only uses real outings.
Tiger Data stores everything. Open-Meteo's hourly forecast, 7 past days and PM2.5 go into a TimescaleDB hypertable on a free Tiger Cloud service, keyed by a 0.05° map cell (about 5 km) and refreshed at most once an hour. Ratings, outlooks and the agent's memory live in the same database. I set up the service and the schema from inside Claude Code with Tiger MCP.
Mastra runs the agent. A Mastra Agent on openai/gpt-oss-120b (open weights, served by Groq) with three tools: the personal forecast (TabPFN's chances plus conditions), your outing history, and logging an outing. Memory is @mastra/pg in the same Tiger database, with working memory for lasting facts (favourite activity, usual length). Groq's free tier allows 8k tokens a minute, and my first version sent JSON tool output that made each answer take 40 seconds while the SDK waited out the limit. Switching the tools to compact text lines ("Tue, 5:30 am | 89% | feels 25C | hum 92 | rain 0% | pm25 44 | uv 0") brought it down to about 8 seconds.
Front end. Next.js 16 App Router, Tailwind 4, motion for the few animations, Phosphor icons. The look is a trail marker: one green sign with the time on it.
Why Does Open Innovation Matter?
Comfort is personal, and so is the data that describes it: where you live, when you go out, what you put up with. With a closed weather app, you get the same answer as everyone else, from a model you can't see, with your habits on someone else's servers.
Every piece here is open. TabPFN's weights are open, so the whole prediction step can run on your own laptop with the tabpfn Python package (the README shows how). I used the hosted API only because my laptop has no GPU, but tables this small run fine on a CPU. The chat model is open-weight, so it can be swapped for one you host. The weather comes from Open-Meteo's open data. And the app is MIT licensed, so anyone can fork it for cycling, birding, or taking the kids to the park.
My Agent Session
https://dev.to/challenges/hacktoberfest-week1-2026-10-05 we gotten the problem statement based on last challeneg i think we should target least populated tracks
Theme out: Touch Grass. Pulling weekend entries now to count claims for all 16 categories (old plan only counted 5).
Grabbing full category text from page HTML; body download still running (~680/1480).
Theme is Touch Grass: "build something with open-source AI at its core that gets people off the screen and into the world." Extra credit if you take it outside, use it, and write about how it went. Deadline is Mon Oct 12, 12:29 PM IST.
Prize amounts changed since PLAN.md. Tiger Data and Mastra are now $100 partner categories. The $200 featured ones are Render, TabPFN, Tinker, Arduino, DigitalOcean and Gemma. You can still win only once.
Week 1 opened at 11:30 PM IST, so it has no entries yet. Weekend entries are the best guide to crowding. I've counted 679 of the 1480 posts tagged hf26challenge so far; the rest are still downloading in the background. These are the posts that listed each category in their Prize Categories section:
| Category | Prize | Claims | Notes |
|---|---|---|---|
| Arduino | $200 | 3 | Needs an Arduino UNO Q board |
| DigitalOcean | $200 | 7 | Needs a card, already ruled out |
| Tinker | $200 | 13 | Free credits at hacktoberfest.com/my/promos. You must show a fine-tune beating a baseline. |
| TabPFN | $200 | 16 | Open model, runs locally on CPU for small CSVs, free |
| Render | $200 | 87 | Crowded |
| Gemma | $200 | 234 | Very crowded |
| Tiger Data | $100 | 6 | Account already set up |
| Temporal | $100 | 10 | |
| Entire | $100 | 12 | Cheap add-on (share agent sessions) |
| Mastra | $100 | 16 | |
| Backboard | $100 | 16 | |
| SerpApi | $100 | 18 | |
| Sentry Agent Tracing | $100 | 23 | |
| GitHub Copilot | $100 | 30 | |
| MongoDB Atlas | $100 | 44 | |
| ElevenLabs | $100 | 55 |
My pick: go deep on TabPFN ($200, few claims, free, fits the theme), with Tiger Data, Mastra and Entire as add-ons. Most of the old plan's setup (Tiger, Mastra, Groq) carries over.
- Idea: a frost and garden window planner. It pulls free Open-Meteo history for your location, TabPFN predicts frost risk for the next nights, and a Mastra agent tells you what to plant or cover this week. Tiger stores the history and the agent's memory. You can test it in a real garden for the extra credit.
- Risk: the challenge page uses a frost-date garden planner as an example, so others may build it too. A less obvious backup is a "best hour to go birding or running" predictor.
If you have an UNO Q, Arduino beats everything else: $200, 3 claims, and a perfect fit for the theme. Tinker is second: 13 claims, but you have to run a real before-and-after fine-tune comparison.
Your schedule file has wrong deadlines. The DEV API shows these, all at 12:29 PM IST:
- Week 2: Sun Oct 18, not Mon Oct 19
- Week 3: Sun Oct 25, not Mon Oct 26
- Week 4: Sat Oct 31, not Sun Nov 1
Do you have an UNO Q? If not, should I rewrite PLAN.md around TabPFN and fix the schedule dates?
i dont have arduino uno so we will hva eto go with your pick but running a llm model on my pc is hard cause of the specs
TabPFN still among least crowded (~30 of 1200 so far). Fixing schedule dates, then rewriting PLAN.md.
Your laptop doesn't need to run any model. TabPFN isn't an LLM, and both models run on free hosted services:
- TabPFN: called through Prior Labs' hosted API with a free account. Its weights are open, so the post can still say it can run fully locally, and the README will show how.
- LLM: gpt-oss-120b (an open-weight model) on Groq's free tier. Your Groq key is already in .env.local.
Your laptop (i5-1235U, 7.5 GiB RAM, no GPU) only runs the code editor and the dev server.
One change to the idea. I dropped the frost garden planner. The challenge page lists it as an example idea, so many people will build it, and frost is rare in India. The new idea is Nice Out:
- You rate about 15 past hours ("would you have gone out?"). TabPFN learns your own comfort line from those few rows. It's built for small tables like this and needs no training step.
- It reads the free Open-Meteo weather and PM2.5 forecast and shows one answer: "Go out 6:10–7:20 AM".
- After each walk or run you tap great, fine or bad, and that becomes more training data.
- A Mastra agent answers questions like "when can I run this weekend?". Tiger stores the weather history, the outing log and the agent's memory.
- For the outdoor extra credit, use it for real from Wednesday to Sunday and report how often it was right.
The final count of weekend posts (1198 of 1480 read) didn't change the order. TabPFN has about 31 claims for a $200 prize, and Gemma has 390.
What I changed:
- Rewrote week1/PLAN.md: categories, idea, setup and a day-by-day timeline.
- Fixed the Week 2, 3 and 4 deadlines and the Week 1 start time in hacktoberfest-schedule.txt.
- Added an empty TABPFN_TOKEN line to .env.local.
- Saved your limits (no card, weak laptop, no Arduino) and the real deadlines to memory for the coming weeks.
What you need to do: sign up at https://platform.priorlabs.ai (check it doesn't ask for a card), create an API key, and paste it into TABPFN_TOKEN. I'll then check that the free usage allowance covers our needs and start building.
<task-notification>
<task-id>bctaenkw3</task-id>
<tool-use-id>toolu_01CzS3YeyQtKUbRwXwFJxrW8</tool-use-id>
<output-file>[scratch]
<status>completed</status>
<summary>Background command "Download article bodies" completed (exit code 0)</summary>
</task-notification>
The background download is done. It got 1351 of the 1480 posts; the other 129 failed, most likely from DEV's rate limit. 1153 of the downloaded posts are weekend entries, and the final counts give the same order as before:
| Category | Prize | Weekend claims |
|---|---|---|
| Arduino | $200 | 7 |
| Tiger Data | $100 | 11 |
| DigitalOcean | $200 | 16 |
| Temporal | $100 | 20 |
| Mastra | $100 | 23 |
| Entire | $100 | 27 |
| Tinker | $200 | 28 |
| TabPFN | $200 | 34, plus 6 more that named "Prior Labs" |
| Render | $200 | 172 |
| Gemma | $200 | 441 |
TabPFN is still the pick, at about 3% of entries for a $200 prize. I've updated the table in week1/PLAN.md with these numbers.
You still need to sign up for Prior Labs, create a key, and paste it into TABPFN_TOKEN in .env.local.
done i created the api key from there you need somehting else? tell me the env file to paste it
Paste it into this file:
~/Code/hacktoberfest/week1/.env.local
I already added an empty line at the bottom of it. Put the key between the quotes:
TABPFN_TOKEN="your-key-here"
Don't paste the key in this chat.
Two more things on the Prior Labs site:
1. Accept the model license under Licenses (https://platform.priorlabs.ai/account/licenses). The hosted API may also need it, and it takes a few seconds.
2. Check your free allowance on the usage page (https://platform.priorlabs.ai/account/usage). Tell me the daily and monthly token numbers. Each prediction costs at least 10,000 tokens, so I need them to plan how often the app can call TabPFN.
Nothing else is needed from you. I'll create the Tiger database and fill in DATABASE_URL myself. Once you've pasted the key, I'll make one small test call to confirm it works, then start building.
[Image #1] done you need anything else from me?
Key pasted without quotes; fine. Testing it with the limits endpoint (free, no tokens used).
The key works. I tested it on the model-limits endpoint, which uses no tokens.
Free allowance: 5M tokens a day and 20M a month (resets Nov 1). Each prediction costs at least 10,000 tokens, so that's about 2,000 predictions for the rest of October. To stay inside it, the app will predict all upcoming hours in one call and reuse that result for the hour. I've added this to PLAN.md.
I don't need anything else from you right now. The only thing I'll ask before doing it is creating the GitHub repo, since that's public: should I make a public repo nice-out under Sarcastic-Soul now, or later once there's working code? Everything else, like the Tiger database and the first TabPFN test, I can start on now.
Your Prior Labs sidebar also shows a TabPFN-3.5 Hackathon. It might take this same project as a second entry. Want me to check its rules?
yeah go ahead create a repo public on my account and start building this project if you have any question ask me or like fnish the project
Tiger login has expired. Please run this in the prompt:
! tiger auth login
I'll start building the rest of the app while you do that.
App scaffolded (Next.js 16 + Mastra 1.74). TabPFN API and Open-Meteo both tested working. Now reading Mastra's bundled docs for the agent setup.
Planning done; Mastra uses groq/openai/gpt-oss-120b. Reading memory/Postgres setup, then writing code.
Tiger still logged out. When you get a minute, run ! tiger auth login. Meanwhile I'm building the 3 design options.
Option 1 clean. Writing options 2 and 3.
Screenshotting the 3 options at phone and desktop width.
Going with option 3. Next: reading the Next.js 16 docs bundled with the app (its AGENTS.md says APIs changed), then writing the backend.
Writing backend libraries now (weather, TabPFN client, database, outlook logic).
Backend routes done. Now the Mastra agent (tools for forecast windows, outing history, logging outings; memory in Tiger).
Writing the UI now in the trail-marker style you picked (welcome screen, quick-start cards, home screen, Ask box).
Now the client helpers and screens.
Building UI screens (home, chat, app shell). Fixing typo in Home first.
Typecheck clean. Now database: check Tiger auth.
Tiger login still expired, so testing on a throwaway local Postgres meanwhile. Making SSL skip for localhost.
Backend works locally (place, 14 quick-start cards). Now testing ratings + TabPFN outlook.
Tiger service nice-out created (free, DEV). Applying schema now.
Hypertable live (TimescaleDB 2.30, PG 18, columnstore on). Writing connection string into env without printing it.
Now night-window fix: only waking hours (5 am–10 pm local) can form a window.
Known pg quirk: sslmode=require in URL overrides ssl options. Stripping it in code.
Works on Tiger. But cached second call took 16 s; should be ~1 s. Checking.
Cached call 1.2 s; the slow one crossed the hour mark (new hour = new prediction). Now chat agent.
Agent works (calls TabPFN forecast tool, answers with times). 49 s first call. Checking warm speed.
39 s warm is too slow. Profiling.
Chat now 8 s. Adding "use listed times exactly" rule, then UI screenshots.
Welcome looks right. Placeholder "Kothrud, Pune" finds nothing in Open-Meteo geocoder; changing to "Pune". Now home screen with test id.
Fixes needed: "Also good" line squeezed by grid rule, night bars look tall (confusing), "Tod" tick label.
Desktop looks right. Now check rule mode + quick-start screen with fresh person.
Hero looks faded. Checking whether the motion entrance stalls.
Just caught mid-animation; final state fine. Checking quick-start screen.
Card reads well. "Tuesday" is ambiguous for last week's Tuesday; switching to "Tue 29 Sep".
Clicking through all 14 cards in browser to test the full UI flow.
Clean. Fixing a race: the last rating could still be saving when home loads. Making quick-start wait for pending saves.
Loading state good. First load ~40 s because holdout check runs after main prediction, sequentially. Running all three TabPFN calls in parallel.
15 s now (was 40). Outing log works. Next: README, LICENSE, git, GitHub repo.
Writing README and LICENSE.
Build passes. Giving Mastra itself the same Postgres store to silence the in-memory warning.
Agent good. Creating repo.
Repo live: https://github.com/Sarcastic-Soul/nice-out. Checking Vercel.
Logged in. Adding maxDuration on outlook route, then linking and setting env vars (piped, not printed).
Keys kept; Vercel only appended a token. Setting env vars on Vercel.
Live at https://nice-out.vercel.app. Full flow test on production.
Checking best-bet screen render (request finished in 1.3 s, page may be stuck).
Renders right. Committing; push auto-deploys.
Only my 3 fake test people in Tiger. Clearing them and their chat memory so the user starts clean.
Saving a project memory, then wrapping up.
Nice Out is built, deployed and tested end to end on production.
- Live: https://nice-out.vercel.app
-
Repo: https://github.com/Sarcastic-Soul/nice-out (public, MIT, README with a Mermaid diagram). Every push to
maindeploys again. There are 8 commits under your name with no co-author lines, and no secrets in the repo. -
Tiger: I made a free service
nice-outthrough Tiger MCP and applied the schema.conditionsis a TimescaleDB hypertable. The database link is in both.env.localfiles and on Vercel, and I never printed it.
What works:
- Setup: pick your place by location or search, then answer 14 "would you have gone out?" cards built from real hours of your past week.
- TabPFN: it scores the next 36 hours. The home screen shows the next window in the big green block, two or three plain reasons, and a bar chart of the hours. When nothing scores 60% or more, it shows the best hour anyway instead of "stay in".
- Logging outings: you tap Great, Fine or Bad. The app also saves the chance it showed for that hour before you went, so the "X/Y called right vs a generic rule" score is honest.
- Mastra chat agent: it uses gpt-oss-120b, has three tools (forecast, history, log outing) and keeps its memory in Tiger.
- Speed on production:
- fresh prediction: about 5 s
- cached: 0.4 s
- chat reply: about 8 s
Problems I fixed while testing:
- Postgres couldn't connect to Tiger because of a certificate error ("self-signed certificate"). The fix was taking sslmode out of the database URL.
- Chat replies took 40 s because Groq's free tier only allows 8k tokens a minute. Shorter tool output brought that down to 8 s.
- The app was suggesting 2 am windows. Night hours (10 pm to 5 am) are now never suggested.
- Times were off by 30 minutes for India's time zone.
- The last quick-start answer could still be saving when the home screen loaded. The app now waits for it.
I deleted my fake test people and their chat history from the database, so you start clean. PLAN.md section 5 is updated.
Still to do (yours or later):
1. From Wednesday, open the site on your phone, do the quick start, and log every real walk or run. That's the "took it outside" bonus and the honest score for the post.
2. Record the video. I can draft the DEV post once there are real outings to write about.
3. Entire hasn't been started yet, and I haven't checked the Prior Labs "TabPFN-3.5 Hackathon" rules.
One limit to know: if several people chat at the same time, Groq's free limit will make replies queue for a bit.
<task-notification>
<task-id>bxijf67rl</task-id>
<tool-use-id>toolu_01RNfQ34nkkekG9XqHHHGJRx</tool-use-id>
<output-file>[scratch]
<status>failed</status>
<summary>Background command "Start dev server again" failed with exit code 143</summary>
</task-notification>
The memory note was saved. The "failed" notice is from the local dev server, which I stopped on purpose to free up RAM. The live site doesn't depend on it.
Next steps are unchanged: from Wednesday, open https://nice-out.vercel.app on your phone, do the quick start, and log every real outing. Once you have a few, I can draft the DEV post.
great job the project is done right
The app is done. It's live at https://nice-out.vercel.app, the repo is public, and everything worked when I tested it on production.
The challenge entry isn't done yet, though. Three things are left:
- Use it outside, starting Wednesday. Do the quick start on your phone and log every walk or run. This gets the "took it outside" bonus, and after 5 outings the app shows its real "called right" score. That score is the best proof for the post.
- Record a short video, about 60–90 seconds, ideally with a clip shot outside.
-
Write the DEV post with the tags
devchallengeandhf26challenge. Writing quality counts the most in judging. I can draft it once you have a few real outings logged.
Two optional extras: the Entire category, and checking the rules for the Prior Labs "TabPFN-3.5 Hackathon" in case the same project can be entered there too.
Week 1 closes Mon Oct 12, 12:29 PM IST. Aim to publish by Sunday night.
Prize Categories
- Best Use of TabPFN: TabPFN is the core of the app. It learns one person's idea of nice weather from 14 rated hours, with no training step, and scores every upcoming hour.
- Best Use of Tiger Data: weather history in a TimescaleDB hypertable, plus ratings, outlooks and Mastra's memory in the same Tiger Cloud database, set up through Tiger MCP.
- Best Use of Mastra: a Mastra agent on an open-weight model, with three tools (personal forecast, history, log an outing) and Postgres-backed memory.
Top comments (0)