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

What I Built
Vision boards are great at making you feel motivated and terrible at telling you what to do on Tuesday. SlothSteps closes that gap, and it does the boring part for you.
You photograph your vision board (or paste a few notes). A local Gemma model reads it and finds your goals. You pick one goal to focus on this week, and SlothSteps writes one concrete action that takes 1 to 10 minutes. Then you check in with a single tap:

• Done: that's the whole job.
• Too big: the agent rewrites the same action to be smaller.
• Skip: no pressure. An unfinished focus carries over.

For a goal as fuzzy as 'Happiness', the first step it gave me was 'Put on your favorite song.' (3 minutes). That is exactly the level of laziness I was aiming for.
Who gets to be lazier? Anyone whose goals die at 'where do I even start?'. The effort SlothSteps removes is the planning: choosing, breaking down, and sizing the next action. What's left for you is one photo, one tap a week, and ten minutes.
For a gentle nudge, you choose a check-in day and download a recurring calendar event. It contains no goal or step details, and the app never sends notifications itself.

Vision board: "I want to take on more craft projects".
SlothSteps: "first organize your craft box"

Upload your vision board - Gemma looks at your board and extracts goals for you! You can manually add a few more goals in as well. Dream big!

One small habit. Nothing more expected! Too big? You can shrink them down simpler.

Every week the goal shuffles, you can download a reminder to check in on the site!

SlothSteps is local-first, so there is no hosted link. Once Ollama is installed, running it takes three commands:

ollama pull gemma3:4b
npm install
npm run dev

Code

How I Built It
Gemma, locally, through Ollama
Gemma (gemma3:4b by default) does both jobs: it reads the board image to find goals, and it writes every action. Ollama serves it on localhost, and switching models is one environment variable (OLLAMA_MODEL). The uploaded photo is held in memory for the request and never written to disk.
Mastra: one agent, three tools, three workflows
The agent (slothStepsAgent) holds the rules for a good step and always answers with a typed object, using structured output with Zod schemas. Around it:

• Tools: extract_goals, pick_next_step and shrink_step. Each one validates the model's answer and retries once, telling the model exactly what was wrong.
• Workflows: scanBoard, planWeek and shrinkStep decide the order of the steps. The tools run directly as workflow steps.

The key design decision: the model never chooses tool calls. A small local model is not reliable at deciding which tool to use, so deterministic Mastra workflows decide what happens next, and the model is only ever asked for a typed object. That kept a 4B model dependable.

Making 'tiny' enforceable
'Make it small' is easy to say and hard to guarantee, so the app checks it. A step has to start with an action verb, fit in 1 to 10 minutes, and name a concrete thing. Vague verbs like 'plan', 'think about' and 'work on' get rejected and retried. When you tap Too big, the new step must be different from the old one and can never take longer.

SQLite and Next.js
Goals, steps and run metadata live in a local SQLite file under ./data, which is gitignored. The runs table stores metadata only (duration, token counts, retries, error class), never goal text or images. The UI and API are Next.js with TypeScript.

Why Does Open Innovation Matter?
A vision board is one of the most personal things you own: your hopes, written down and pinned up. With a closed API, using AI on it means uploading that photo to someone else's server. With an open-weight model running through Ollama, the photo and the goals never leave my laptop, and anyone can verify that by reading the code.
That is also what made the rest possible:

• No cost and no rate limits. An app meant to take ten minutes a week shouldn't need a meter running. [ADD: your measured numbers from the runs table, such as average latency per action on your laptop and tokens used]
• Swappable and inspectable. Changing the model is one variable, and the rules for a good step are readable in the repo rather than hidden behind an endpoint.
• Room to build around a small model. Because Mastra is open and composable, I could wrap a 4B model in deterministic workflows and validation instead of hoping it would call tools correctly.

Slow and steady suits local AI. It isn't the fastest option, but it is yours.

The Lazy Payoff 😂

• Planning time this week: 0 minutes. Total time spent building the app that saved me those 0 minutes: [~10 hours]. We don’t talk about that.
• Steps completed: [1]. The first step for “Happiness” was “Put on your favorite song.” I did it. It worked better than most of my planning ever has.
• Times I tapped Too big: [uncountable]. The app shrank the step each time, without judgment, which is more than my to-do list has ever managed.
• Existential dread on Monday morning: noticeably lower. I didn’t have to decide what to do about my life, only what to do for 5 minutes.

Prize Categories

• Gemma: a local Gemma model reads the vision board image and writes every action, fully on-device through Ollama.
• Mastra: a Mastra agent with structured output, three tools, and three workflows orchestrating them, built around a small open model.