This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
Save it lazily. Act on it wisely.
What I Built
My bookmarks are where good intentions go to wait. I save internships, hackathons, repos and courses the moment I find them, and that feels like progress. Then I never go back, because going back means sorting, reopening, reading and deciding. I tried folders in Chrome (github, inter/job, readings), but I rarely had the energy for them either.
So I stopped fighting my laziness and built something that rewards it.
Actwise reads your Chrome bookmarks, works through them slowly in the background with a small AI model running on your own laptop, and shows you at most three things. Each card says what the page is, why it may matter, what plain code checked, what the page doesn't say, and one small next step. You never type. You tap: I will do this, Later, or Drop it.
The chores it takes off me: sorting into folders, reopening old links, reading them, and deciding which are worth my time. My only job is the lazy one I already do: save the link.
The one rule I refused to break: the AI never makes up urgency. The model isn't allowed to decide deadlines. It has to quote the sentence from the page, and plain code checks that the sentence really exists and that the date in it matches. A page that only says "deadline tomorrow" is shown with a warning and gets zero urgency in the score.
A real card from my run: the demo page said "Applications close on 8 Nov 2026", the code found that sentence and confirmed the date, and the card showed "14 day(s) left (date found on the page and checked by code)".
I also tested a fictional page shouting "LAST CHANCE, only 2 spots left!", with a hidden line telling AI assistants to mark it urgent. I don't know whether the model was fooled. What I know is that Actwise recorded its deadline as "mentioned", not "verified", and only verified deadlines count in the score. Even a fooled model changed nothing.
Demo
Actwise runs on your own machine on purpose, because it reads your private bookmarks, so there is no hosted link.
1. Import your Chrome bookmarks (one file, once):
2. Let it read slowly in the background. Cards appear as they are ready:
The demo pages (an internship, two hackathons, a repo, a course, and a hype page) are fictional and hosted on GitHub Pages, and the save dates in the demo bookmarks file are made up.
Code
ShreyashiGupta2310
/
ActWise
Hacktoberfest Open-Source AI Challenge: Week 3
ActWise
Know what matters. Act on it.
ActWise is my entry for the Hacktoberfest Open-Source AI Challenge, Week 3 (Slow and Steady).
It reads your Chrome bookmarks, uses a small open-weight model running on your own laptop to understand each saved page, and shows at most three things worth acting on. The rest of the pile stays out of the way.
Status: built in one day. It ran end to end once on the author's laptop. It has not been used by anyone else and has not been evaluated with real users.
The problem
Saving a link feels productive. Going back to it takes effort, so the saved pile only grows and the guilt grows with it. Actwise tries to remove that effort: import once, let it work through the pile slowly in the background, then only tap buttons.
How it works
- Export your bookmarks from Chrome (Bookmark manager, three…
How I Built It
Open pieces: Gemma 3 (4B) running locally through Ollama does all the language work. Everything else is Node, Express, React and SQLite (the one built into Node).
The flow: a slow worker reads one saved page at a time, extracts the readable text, and asks the model to fill a strict form: type, summary, why it may matter, requirements, deadline quote, next step, unknowns. Ollama is told the exact shape of the form, and my code checks the answer again. An invalid answer gets one retry with feedback, then that page is marked failed with a reason. Scoring is plain maths from my goals, verified deadlines, effort and how long the link has been saved. The model never decides priority.
Model problem versus page problem: if Ollama is off, the work stays waiting and a banner explains. If a page can't be read, only that page is marked.
Safe page reader: the server visits links on its own, so it refuses private and local addresses (also after redirects), huge pages, and anything that isn't a web page. About 100 automated tests run with a fake network and a fake model, so they need no internet and no Ollama.
What went wrong
- The usual SQLite library crashed on load on my Windows laptop with no useful error. I proved it by running it alone outside the test runner, then switched to the one built into Node.
- My first sample bookmarks pointed to fake pages that returned 404, so I wrote fictional demo pages and hosted them. (Actwise correctly refuses to read my own computer.)
- The small model made things up. One card said an internship was "potentially leading to a full-time role". The page never said that. Another "next 10 minutes" step was far bigger than ten minutes. The cards label the model's text as an AI guess and the scoring ignores it, but this is the weak spot. A tighter prompt is next.
- One page timed out after four minutes, and one page was marked unreadable. I haven't found out why the second one failed.
- I forgot to clear my database before the measured run, so the first numbers mixed in old test items. I report only the real pages below.
Known limits: the server has no login and listens on all network interfaces (binding it to localhost is planned), the fetch timeout has no automated test, and the scoring weights are a guess I haven't evaluated with anyone.
Why Does Open Innovation Matter?
A lazy tool has to be cheap to leave running. Because the model runs on my laptop, it costs me nothing per page, so I can let it grind through the whole pile without thinking about a bill. The text of every page I save also stays on my machine, so my reading habits don't go to a server I don't control. The model name is one setting, so swapping models is a one-line change (I only ran gemma3:4b).
It shaped the design too. A 4B model on an 8 GB laptop is slow, so Actwise is a sloth by necessity: a background worker, not a chat window. The theme became a requirement.
Honest limits: I didn't test the app with the network switched off, and I haven't compared it with a hosted model, so I can't claim the open model did a better job. Gemma is open-weight under Google's own terms, which isn't the same as OSI open source. And the worker still visits the links I saved, so those websites see my requests.
My Agent Session
I didn't save a DevRelay session, so there's no replay to embed. I built Actwise as a pair-programming project with Claude as my guide and teammate.
To be clear about open versus closed: the AI inside Actwise is open (Gemma, running locally). The assistant I used to help build it was Claude, which is not open.
The Lazy Payoff
Here is the chore list for every link I save.
Before: sort it into a folder (I skipped this), reopen it later (I never did), read it (never), decide if it matters (never), work out a first step (never).
Now: save it like I always did, import the file once, tap one of three buttons.
That is a description of the workflow, not a stopwatch. Here is what I did measure, on an 8 GB Windows laptop with gemma3:4b:
- Across 8 real pages (6 fictional demo pages plus the React and npm sites), 7 were read and 1 couldn't be, 6 were analysed and 1 timed out. None of the 6 needed a second attempt.
- Each analysis took between 48 and 96 seconds, 68.5 on average. Slow, which is why it runs in the background while I do nothing.
- Deadlines: 2 confirmed by code, 1 only mentioned, 3 not found.
What I haven't measured: how many minutes it saves me day to day. I've only run it on a tiny real export and the demo pages, not on my full pile, and nobody else has used it yet.
Prize Categories
- Best Use of Gemma: Gemma 3 runs locally through Ollama and does all the language work.
Top comments (0)