This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
What I Built
Everyone has a task that keeps sliding to later. "Plan the December trip" was due Monday, then Wednesday, then Friday. The work itself is rarely the hard part. Starting it is: the blank page, the first outline, the first list of what you even need to decide.
Ripe is a greenhouse for those tasks. You write what you keep putting off in one sentence, say when you'll be back, and leave. While you're away, an open-weight model running on your own machine works on it in small, saved steps: it reads the request, maps out the work, writes one piece per step and reviews the whole set. When you come back, there is a plan, a draft or a checklist waiting for you, plus a short list of the things only you can answer.
Every task is a plant, and a plant only grows when real work is saved:
- the seed germinates when the agent has understood the request;
- a bud appears on the stem for each step it plans;
- each finished step opens into a leafy branch you can click to read;
- the plant blossoms with the first piece, sets fruit when most of the work is done, and ripens once everything has been reviewed;
- a bud that needs an answer from you dries out and shows a small blue drop.
Running through the soil is a glowing mycelium: that's the agent. You can watch a pulse of light travel from the mushrooms at the edge of the bed to the plant it is feeding, and the whole network turns grey if Ollama stops. Harvested tasks are preserved as jars in the pantry.
Opening a plant shows its specimen sheet: the plant drawn as a botanical plate whose numbered parts are the pieces of work, next to where the task stands (what the agent has finished, what it needs from you, what is ready to read), the text being written right now, the agent's questions and a reading room. Every piece can be edited, copied, downloaded as Markdown or rewritten on request ("shorter and more direct"), and the previous version is always kept.
Who gets to be lazier: anyone with a task they keep postponing. You don't chat with it, write prompts or watch it work. Putting the task off is the whole interaction.
Demo
Music: "Cylinder Five" by Chris Zabriskie (chriszabriskie.com/cylinders), licensed under CC BY 4.0.
Everything in the film is a real run of gemma4:e4b through Ollama on my laptop, including the tasks growing in the background. The growth sequence is a timelapse of a 13-minute run and the film says so on screen; the live writing and the rewrite are shown at real speed, and the Ollama outage is a real 22-second stop. The app also ships a hand-written example task for a quick look, and the interface marks it as illustrative.
Code
maricastroc
/
ripe
Tasks that ripen while you procrastinate. Put something off and a local AI agent on Ollama works on it in small, saved steps, drawn as a plant that only grows when real work gets done.
Ripe
Tasks that ripen while you procrastinate.
You write down something you keep putting off — "reply to the difficult client email", "plan the December trip" — and leave it for later. From then on, an AI agent running locally on Ollama works on it in small steps, saving every result. When you come back, you find a plan, a draft, a checklist or a first version — and a clear list of what still depends on you.
Built for the Hacktoberfest Open-Source AI Challenge, week 3: Slow and Steady.
The flow
Create → Put off → Ripen → Return → Review
- Create — one sentence in plain language. No forms.
- Put off — say when you plan to come back ("tomorrow", "next week"). The agent starts.
- Ripen — the agent interprets the request, splits it into steps, writes one piece per step and finally reviews the whole set.
- …
Next.js, SQLite and Ollama. With Ollama running: ollama pull gemma4:e4b, then npm install, npm run setup and npm run dev.
How I Built It
Ripe is a Next.js 16 app (App Router, React 19, TypeScript, Tailwind CSS 4, Motion, Radix UI) with Prisma 7 on SQLite. All of the AI is Gemma through Ollama, on the same machine. The model can be changed from the interface.
The agent is a queue, not a chat loop
Every task goes through separate jobs: interpret (understand the request and point out what's missing), plan (split it into three to five steps), generate (one piece per step), review (a critical read of the whole set) and revise (a rewrite you asked for). Interpreting, planning and reviewing use structured output: each response is checked against a Zod schema that is also sent to Ollama as the JSON format. The pieces themselves are streamed as Markdown.
Jobs live in SQLite with explicit states (queued → running → done | failed | cancelled). A worker started from instrumentation.ts runs inside the Next server and takes one job at a time:
- Recoverable. A running job holds a lease. If the process dies mid-step, the job goes back to the queue on restart and the journal records the interruption. Nothing already saved is lost.
- Patient with Ollama. The worker checks Ollama's health before taking a job. If Ollama is down, nothing is consumed: the job waits and the work resumes on its own. That's the outage in the demo.
- Bounded. Three attempts per step with growing back-off, four minutes per call, up to 24 runs per task, and a configurable rest between steps.
The plant can't lie
The interface reads the real state from the database. The text you see being written is the model's stream, saved every ~700 ms. Growth is computed only from persisted milestones (request understood, plan saved, steps finished, review saved), never from the passage of time, so a plant that looks ripe really has every piece written and reviewed behind it.
It asks instead of guessing
When the request is missing something, the agent says so. Questions are marked essential or optional, and essential ones only hold back the final step, so everything else keeps moving. Inside the text, unknowns are written as [[TBD: ...]] markers that the reading room highlights as gaps, instead of invented answers. Once you answer, one click rewrites the pieces that still have gaps.
Drawn, not decorated
Each plant is a procedural SVG generated from the task's id, so the same task always grows the same way. The species comes from the kind of result the agent decided you need: persimmon for plans, plum for documents, lemon for presentations, fig for messages. Opening a plant morphs it from the bed into the plate of its specimen sheet with a view transition.
Why Does Open Innovation Matter?
Ripe only makes sense if the model is open and local. Three reasons:
- Procrastination has to be cheap to waste. Ripe works on things you might never come back to. With a per-token API, every abandoned task is a bill. Here, the cost of a task you ignore is some electricity and some time, and time is exactly what a procrastinator is offering.
- Slow is fine when it's yours. No rate limits and no latency budget. A small open-weight model that takes 40 seconds per step would feel sluggish in a chat window. In a greenhouse you're not even looking at, it's perfect. The whole design leans on that: small steps, saved as it goes, a rest between them.
- What people put off is personal. The reply to a client who is upset, a trip budget, a family plan. None of it leaves the machine: requests, drafts, answers and the journal all stay in a local SQLite file.
And because every part is open, it's all inspectable and changeable: the prompts, the schemas, the queue and its limits are in the repo, and the model is a setting.
The Lazy Payoff
From the run in the demo, on a MacBook Air with an M4 chip:
| You did | Ripe did |
|---|---|
| Typed one sentence (14 words): Plan a 4-day trip to Lisbon in December for two, on a moderate budget | Read it, planned five steps and wrote for 13 minutes on its own |
| Answered one question (10 words): About 150 euros a day for the two of us | Finished the last step and reviewed everything five and a half minutes later |
| Came back | Five pieces (2,545 words: structure, activities, a day-by-day schedule, budget notes and the final itinerary) plus a 284-word review. What it couldn't know, like your interests or which day trip to take, was left marked as a gap instead of invented |
About 20 minutes of wall-clock time, none of it spent watching. That run was slower than usual because the same laptop was recording the film; without the recording, it reads the request in about 22 seconds, plans in about 11 and writes each piece in 33 to 49 seconds.
Prize Categories
Best Use of Gemma: Ripe runs entirely on gemma4:e4b through Ollama, on the same machine. Gemma interprets each request, plans it, writes every piece, reviews the set and rewrites on request, with structured JSON output for interpreting, planning and reviewing, and streamed Markdown for the pieces.
Top comments (1)
"The plant can't lie" is the best design principle I've read this week.
Most "AI does the work for you" tools show progress bars that are disconnected from reality. Your plant grows only when a milestone is saved to the database, which means the visual state is always an honest reflection of what the agent actually did.
Curious how you handle the "the agent fails mid-task" case. Does the plant wilt, or does it just stop growing until the task is resumed?