Oracle：一款讓你對不想理會的任務「已讀不回」的 Tinder 式追蹤器

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

What I Built

Some tasks need doing. Some disappear because the meeting gets cancelled or everybody forgets why the thread existed.

I wanted to make a joke out of telling those apart. So I built Oracle, a Tinder-style task tracker with Gemma as your wingman.

You add a task and a backstory. Gemma writes its dating bio and tells you whether it looks like something you can leave on read. Swipe left if you did it. Swipe right if you think it will sort itself out.

Then come back with the receipts. If an ignored task really did go away, you get a point. If you had to do it anyway, you lose one. Doing something immediately costs nothing. The score is your record of predictions, not a productivity streak.

The theme is Slow and Steady. Oracle takes the laziness part literally: sometimes doing nothing works, and sometimes your laundry is still on the chair. I wanted the app to let you laugh at both outcomes.

Demo

Meet your unfinished business

Oracle is live on Vercel, with email/password accounts and MongoDB Atlas for saved tasks. Sign up, add a task and click Wake Gemma on a compatible desktop browser. The first model download is about 3.4 GB; the card controls work while it loads.

The screenshots below were captured in the local build in Brave before deployment.

For a task about 37 forgotten browser tabs, Gemma introduced itself like this:

I'm a collection of digital procrastination. Let's see if you can keep up.

It recommended leaving the task on read. Its explanation leaned into the relationship joke, which tells you something about the limits of this very unserious wingman. You still make the call.

The README task appears as completed with no score penalty. Only tasks ignored first count as predictions.

The layout also works at a narrow width. This capture uses desktop device emulation, so it is a layout check rather than proof of phone inference support.

For local setup, see the README. There is no model API key to bring and no Ollama installation to manage.

Code

Oracle on GitHub. Application code is MIT licensed.

How I Built It

Oracle uses Next.js, React, TypeScript and MongoDB Atlas. Vercel hosts the app and its API. Email/password login creates a signed HTTP-only session cookie, and each task belongs to the signed-in account.

flowchart LR
    Browser[Task cards in the browser] <-->|Tasks and outcomes| API[Next.js API on Vercel]
    API <--> Atlas[MongoDB Atlas]
    Browser <--> Worker[Gemma WebGPU worker]
    HF[Hugging Face model files] --> Worker

The dating-profile idea is where Gemma fits. A task title and backstory go to Gemma 4 E2B, running through Transformers.js and ONNX Runtime in a browser Web Worker. The weights use q4f16 quantization and a pinned revision. The worker keeps inference off the main UI thread, so the card controls remain usable.

Gemma returns three things: a short dating bio, an ignore or do_it recommendation, and a reason. The app validates that structure before showing it. A missing or malformed answer produces a retry option. There are no canned model replies.

I keep the game rules in ordinary code. Gemma never writes a task outcome or awards points. An ignored task only earns or loses a point after the person reports what happened. Undo clears the prediction and its timestamps. The server checks ownership and valid state transitions before updating MongoDB.

The first bio sounded like someone trying to motivate me to tackle a digital backlog. That missed the joke. I tightened the prompt so the task speaks as itself, with a short, concrete line instead of a pep talk:

Speak as the task itself, addressing its owner as a potential date.
Never speak as the person doing the task.
Use one dry, concrete joke.

The prompt separates task text from instructions and asks for conservative advice around health, safety, bills and real deadlines. The model can still be wrong. This is a pet project about questionable choices, and I wanted the actual scoring to stay predictable.

The browser inference approach builds on my earlier Pawpath work. Oracle's task game, dating-profile prompt, swipe flow and scoring are its own project. I used coding assistance while building it and reviewed the resulting behavior in the app.

What I checked

The local checks pass lint, TypeScript through the production build, and seven tests. They cover scoring, undo, invalid transitions, reply validation and the task-data boundary in the prompt.

In Brave, I added a task through the real MongoDB flow, left it on read and used undo to restore it. The card and counts updated together. Gemma completed the download and warmup, then returned a validated bio and recommendation.

After a reload, the saved task was still there and Gemma woke from cached files. That second visit matters when the first download is several gigabytes.

The same lint, test and build checks now run on pushes and pull requests through GitHub Actions. The published repository's first checks run passed.

Why Does Open Innovation Matter?

I can run the wingman on my own GPU, inspect its prompt, pin the model files and change the runtime without rebuilding the task game around a hosted API. Each joke does not need another paid model request.

Gemma's open weights, the community ONNX conversion and Transformers.js make that possible from a browser tab.

The tradeoff is noticeable. The first download is large, compatible WebGPU hardware is required, and browser storage can evict cached weights. A desktop browser with WebGPU and half-precision support is the intended place to try the wingman.

Local inference also has a specific meaning here: the model processes task text in the browser. The task list and account still live on the server in MongoDB. The app needs that connection and is not fully offline.

A couple of useful reads

The community has been exploring the same browser-inference tradeoffs. jtorchia's I Stuffed a Tiny LLM Inside a Next.js App describes the friction around downloads, memory and device support. Matt Busel's Run an LLM in the browser: WebGPU did 63 tokens/s, WASM did 1.6 is another useful comparison. Those are their experiments; Oracle's evidence here is the working browser flow and captures above.

Prize Categories

• Best Use of Gemma: Gemma 4 E2B generates the task dating bios and the wingman's recommendations in the browser.
• Best Use of MongoDB Atlas: Atlas stores accounts, tasks, ignored predictions and reported outcomes behind the Gemma-powered app.
• Best Use of GitHub Copilot: the category's GitHub Actions automation option, with a passing checks run. This entry uses Actions automation.

These categories follow the Week 3 descriptions.

Oracle's payoff is small: a funny second opinion and a record of whether ignoring something worked. I have not measured hours saved. For now, I have a to-do list that lets my unfinished tasks flirt with me. That is probably enough responsibility for one browser tab.