Not Yet 待辦規劃工具計算用戶可延後處理清單多久

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

A team entry by @mohnishrawat, @rubercuber6129 and @aditya_dhawan_ee0e786a8ce. Mohnish built the extraction and the scheduler and ran the benchmark, so the "I" below is Mohnish. Pranav redesigned the page around the 14-day chart. Aditya tested it and fed back on the plan and the page.

What I Built

I wanted a to-do app that answers one question: how long can I put this off?

Not Yet does that. You paste the brain dump that's been rattling around your head all week, in whatever order it comes out, and it tells you the exact moment you have to start caring. When I ran it on Tuesday morning with a typical uni week, it said:

You can relax until Wed 21 Oct, 22:00.
That's 1 day 10 h of doing absolutely nothing about this list.

Gemma 4 reads the mess and pulls out each task with its deadline and a guess at how long it takes. Then a scheduler works backwards from every deadline. Each task goes as late as it can safely go inside the hours you're willing to work (weekday evenings and weekend afternoons by default), and everything finishes 12 hours early as a safety margin.

What you get:

• A relax-until time. The first moment anything on the list needs you.
• A 14-day chart. One row per day. Work shows up only where it has to go, and moves when you change the margin or an estimate.
• Sloth days. Days in the next two weeks with nothing scheduled at all. That uni week had 9.
• "Just do these now." Anything under five minutes, like replying to your mum.
• Bad news early. If something won't fit even if you start right now, it tells you how many hours you're short.
• A calendar file you can import into Google Calendar or Apple Calendar.

I built it for students in week 9 of semester, like me, and for anyone whose to-do list is mostly background guilt.

Demo

Try it: https://not-yet-uomu.onrender.com (it's on Render's free tier, so the first visit can take up to a minute to wake up)

1. Click Uni week, then Tell me when I have to care.
2. Set Finish early by to "0 h (living dangerously)" and watch the work slide later.
3. Change any effort or deadline in the table. The plan updates instantly without calling the model again.

It works on a phone too, and follows your system's dark mode:

Code

Not Yet 🦥

The laziest schedule that still hits every deadline.

Paste the to-do brain dump that's been living in your head. Not Yet reads it with Gemma 4, an open-weight model, works out what each thing needs, and schedules every task as late as it can safely go inside the hours you're actually willing to work. Then it tells you the one thing you wanted to know: how long you can do nothing.

• Relax-until time. The first moment any task needs you, and how long that is from now.
• Sloth days. Days in the next two weeks with nothing scheduled at all.
• Two-minute jobs go in a "just do these now" list, because doing them is lazier than remembering them.
• Honest warnings. If something won't fit even if you start now, it says so and by how many hours.
• One click to your calendar (.ics), and every number and…

How I Built It

Small open models are good at reading messy human text and less reliable at arithmetic. So in Not Yet, Gemma does the reading and Python checks anything that has to be exact.

1. Gemma turns the brain dump into tasks

Gemma 4 gets your text, plus the current time and a three-week calendar for reference. It returns JSON with a title for each task, effort in hours, whether it's a two-minute job, whether it has to happen in one sitting, and whether it's a task or a fixed event like a class.

Two extra fields keep it honest:

• quote: the exact words the task came from. If that quote isn't in your text, the UI flags the task with "Couldn't find this in your text. Check it."
• when: the exact words that say when it's due.

If the JSON doesn't parse, it goes back to Gemma once with the error message.

2. Dates are maths, so code does them

I only found this because I measured it. The benchmark runs the three sample brain dumps through Gemma 4 E4B on my laptop five times each and compares the output with 22 tasks I labelled by hand. Gemma found almost every task (108 of 110), but it got the deadline right only 63 times out of 98. It would read "friday 11:59pm" perfectly and then put it on the wrong Friday, or turn "next tuesday" into a Wednesday.

So now Gemma just copies the date words it saw, and a small resolver in Python turns phrases like "next tuesday 9am" or "before the 25th" into real datetimes. When the resolver doesn't know a phrase ("in march", "eventually"), Gemma's own answer is kept.

The benchmark caught the resolver's first version out too. It scored 92/100, and one miss came up in every run. For "cancel the gym trial before it charges me on the 28th", Gemma copied only "the 28th", so the plan let me cancel on the day it charges me. The resolver now looks back through the sentence for a dropped "before", and the prompt asks Gemma to keep words like "by" and "before" when it copies. These are the samples I developed against, so 98/98 only means there are no known failures on them. The labels are in the repo if you'd like to argue with them.

3. Scheduling backwards

Working hours are cut into 30-minute slots. Starting with the task due last, each task takes the latest free slots that end before its deadline minus the margin:

for t in sorted(dated, key=lambda t: (t.deadline, t.id), reverse=True):
    need = slots_needed(t.hours)
    status = "scheduled"
    idxs = _pick(free, taken, t.deadline - margin, need, t.splittable)
    if idxs is None:   # only fits if it eats the safety margin
        status = "tight"
        idxs = _pick(free, taken, t.deadline, need, t.splittable)
    if idxs is None:   # doesn't fit at all: take what's left, report the gap
        status = "short"
        ...

A simple greedy is enough here. If you flip time around, every deadline becomes a start time and you get a textbook problem with one worker and jobs that become available at different times. For that problem, any schedule that never sits idle while work is waiting finishes as early as possible. So if a valid plan exists, this one finds it.

A test backs that up. It generates 300 random to-do lists and compares the scheduler with a brute-force capacity check, and the two agree on all 300.

4. A brief that can't make things up

Gemma also writes a short morning brief in the voice of a calm sloth, using facts the scheduler computed. Python then checks that every time in the brief appears in those facts. If Gemma invents "start at 8:30", the brief is thrown away and a plain template takes its place. The page tells you which one you're reading.

Stack

• Gemma 4. E4B (4-bit, through MLX) on my MacBook while building and benchmarking. 26B A4B through Google AI Studio for the live demo, so judges don't need a GPU.
• Python and FastAPI, with one HTML page and plain JavaScript. The chart is hand-written SVG. No build step.
• Render hosts the live demo on its free tier. The repo has a render.yaml blueprint, so you can deploy your own copy.
• 70 tests, including mocked HTTP for both model backends and the random scheduler check.

We both used Claude Code as our coding agent. The app itself runs only on Gemma.

Why Does Open Innovation Matter?

A to-do list is basically a diary. Mine has a visa form on it and a message I've been avoiding. With an open-weight model, none of that has to leave my laptop. I built and benchmarked Not Yet entirely offline. Gemma 4 E4B on a MacBook (M5, 16 GB) took a median of 20.4 seconds per brain dump across the 15 benchmark runs, and it cost nothing.

Open weights also meant I could look inside. Early on, one extraction call took 65.5 seconds. The chat template is open, so I could see Gemma 4 was reasoning before it answered (about 1,750 extra tokens) and switch that off. The same call then took 18.5 seconds, and the benchmark shows the task doesn't need the reasoning.

Switching models takes three environment variables. The same code talks to local servers like Ollama and mlx_lm.server, or to Gemma on Google AI Studio. The live demo uses the bigger hosted model so it's fast for everyone, and you can run the small one on a plane.

Running locally also made it cheap to be careful. The benchmark that found the date bug does 15 full extractions, and I re-ran it after every fix for free. On a paid API I'd probably have run it less often and shipped the bug.

The Lazy Payoff

On that uni week, Not Yet found 13 hours of real work in a list that felt much longer. The first block didn't start until Wednesday night. Nine of the next 14 days stayed completely empty, and two of the jobs were small enough to finish before my coffee went cold.

We ran the same uni week on the live demo on Sunday 25 Oct. Gemma 4 26B A4B read it in 17 seconds, and Not Yet said we could relax until Monday at 19:00. The algorithms problem set was already 2 hours short even if we started right away, and the page said so at the top. A normal to-do list would have shown it as one more line.

Prize Categories

• Best Use of Gemma: Gemma 4 does all the language work, reading the brain dump and writing the brief. It runs locally with E4B and in the live demo with 26B A4B through Google AI Studio.
• Best Use of Render: the app and its API run on Render's free tier, and the repo includes a render.yaml blueprint for deploying your own copy.