Momentum: An AI-Powered Activity Prioritizer for Analysis Paralysis

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Momentum for my wife, who struggles with analysis paralysis when facing multiple competing priorities. She describes it as "having 47 browser tabs open in my brain" — every task feels equally urgent, every deadline feels immediate, and the mental load of choosing becomes so overwhelming that nothing gets done.

Momentum is a voice-first, AI-powered activity prioritizer that helps her break through decision paralysis by:

1. Capturing tasks via voice (no typing friction when she's already overwhelmed)
2. Applying multi-factor heuristics to score each task across dimensions like urgency, importance, energy required, time available, and emotional weight
3. Explaining its reasoning in plain language so she can trust (and override) the recommendation
4. Suggesting the single smallest next action for the top task, not the whole project
5. Learning from her feedback to improve future recommendations

The app doesn't just dump a sorted list back on her — that would be another source of overwhelm. Instead, it presents one clear recommendation with a "why," gives her agency to accept, defer, or reshuffle, and celebrates the small wins to build momentum.

Demo

The demo shows:

• Voice input via ElevenLabs for task capture
• Real-time prioritization using Gemma 2B running locally
• The "One Thing" view that hides everything except the current recommendation
• Energy-aware scheduling (won't suggest high-energy tasks when she marks herself as drained)
• Feedback loop where she can rate recommendations to improve future scoring

Code

jedau / momentum

A voice-first, AI-assisted activity prioritizer for people who get stuck when everything feels equally urgent.

Momentum

A voice-first, AI-assisted activity prioritizer for people who get stuck when everything feels equally urgent. Instead of returning a sorted list (which is just more overwhelm), Momentum picks one task, explains why, and suggests the smallest next action.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

What it does

• Capture by voice or text — no form required. A parser infers urgency importance, energy demand, duration, and emotional weight from plain language.
• Multi-factor scoring — urgency, importance, energy match, time fit, and learned history, combined with transparent weights.
• One Thing view — hides everything except the current recommendation, with a plain-language explanation you can inspect (per-factor breakdown included).
• Smallest next action — turns "organize the garage" into "pick up one thing and decide keep / trash / donate".
• Agency and feedback — accept, defer, reshuffle, mark done, or flag "too big". Those choices feed the history…

View on GitHub

The repository includes:

• Full Next.js application with TypeScript
• Docker setup for local Gemma inference via Ollama
• Mastra agent configuration for orchestration
• MongoDB Atlas schema and vector search indexes
• Temporal workflow definitions for durable task processing
• Sentry configuration for agent tracing

How I Built It

Architecture Overview

Momentum is built around open-source AI at every layer:

Local Inference with Gemma (Google)
I run Google's open-weight Gemma 2B model locally via Ollama for all NLP tasks — parsing voice transcripts into structured tasks, generating the "smallest next action" suggestions, and explaining prioritization reasoning. Running locally means my wife's task list never leaves our network, which matters for personal data like medical appointments or sensitive work tasks.

Agent Orchestration with Mastra
The core prioritization logic is wrapped in a Mastra agent workflow that:

• Ingests tasks from voice or text input
• Applies scoring heuristics (Eisenhower Matrix + Energy Accounting)
• Generates explanations using Gemma
• Handles user feedback loops

Mastra's tool-calling interface let me connect the agent to MongoDB for persistence and to Temporal for durable execution.

Vector Memory with MongoDB Atlas
I use MongoDB Atlas Vector Search to store task embeddings and historical patterns. When my wife adds a new task, the system searches for similar past tasks to learn what she actually prioritized in comparable situations — not just what she said was important. This catches patterns like "I always defer the 'important but not urgent' health tasks even when I mark them high priority."

Voice Interface with ElevenLabs
The voice capture uses ElevenLabs for transcription, but the key feature is the voice persona — I fine-tuned a calm, non-judgmental voice that reads recommendations back to her. When you're already feeling overwhelmed by your to-do list, a harsh robotic voice makes it worse. This one sounds like a patient friend.

Durable Workflows with Temporal
Task prioritization isn't instant — it involves embedding generation, model inference, and database writes. I wrapped the entire flow in a Temporal workflow so if her laptop dies mid-processing, the workflow resumes exactly where it left off. No lost tasks, no duplicate entries.

Deployment on Render
The app is deployed on Render with a Web Service for the Next.js frontend and a Background Worker for the Temporal workflows. Render's native support for long-running processes made it perfect for the agent orchestration layer.

Agent Tracing with Sentry
I instrumented the Mastra agent with Sentry's agent tracing to see exactly how many tokens each prioritization request uses, where latency spikes happen, and how often the model generates invalid outputs. This helped me tune the Gemma prompts and catch when the local model was struggling with complex multi-task inputs.

The Prioritization Algorithm

The scoring combines explicit user inputs with learned patterns:

Priority Score = (
0.30 × Eisenhower_Urgency +
0.25 × Eisenhower_Importance +
0.20 × Energy_Match (task energy vs. current energy) +
0.15 × Time_Fit (task duration vs. available window) +
0.10 × Historical_Pattern (what she actually did with similar tasks)
)

Gemma generates the "smallest next action" by taking the top-scored task and prompting:

"Given this task and her current energy level, what is the absolute smallest first step she could take in under 5 minutes? Be specific and encouraging."

Why Does Open Innovation Matter?

Privacy by Design
My wife's task list includes sensitive things — doctor appointments, work conflicts, family concerns. Running Gemma locally via Ollama means that data never hits a third-party API. The voice transcripts are processed through ElevenLabs (which she opted into), but the actual task content, priorities, and patterns stay on our hardware or in our MongoDB Atlas cluster.

Inspectability and Trust
Analysis paralysis thrives on opacity. If an app says "do this task" with no explanation, she'll second-guess it into oblivion. Because Gemma is open-weight, I can inspect exactly how it generates explanations and tune the prompts to be more transparent. She can ask "why this task?" and get a real answer grounded in the scoring heuristics.

Adaptability Without Vendor Lock-in
If Gemma 2B starts feeling too small for her growing task history, I can swap in Qwen 3, Llama 3.2, or any other open-weight model without rewriting the application. The Mastra orchestration layer is model-agnostic. Compare that to being locked into GPT-4's API pricing and rate limits — for a personal tool that might run for years, that matters.

Cost Sustainability
A hosted API would cost $0.01-0.03 per prioritization request. That sounds small until she's capturing 20+ tasks daily and iterating on priorities throughout the day. Running Gemma locally on her existing laptop costs nothing per request, making the tool sustainable for daily use without budget anxiety.

Community Improvement
Because every component is open-source, I can contribute back. I filed a small PR with Mastra to improve their Ollama integration, and I'm documenting the Gemma fine-tuning process for voice-tone adaptation. The tool improves as the ecosystem improves.

Prize Categories

I'm entering the following partner categories:

• Best Use of Gemma — Core prioritization and explanation generation runs on Google's open-weight Gemma 2B model
• Best Use of Mastra — Agent orchestration, tool calling, and workflow management built on Mastra
• Best Use of MongoDB Atlas — Vector search for task similarity, long-term memory for patterns, and document storage
• Best Use of ElevenLabs — Voice transcription and text-to-speech for the voice-first interface
• Best Use of Temporal — Durable workflows for task processing that survive interruptions
• Best Use of Render — Web service and background worker deployment
• Best Use of Sentry Agent Tracing — Instrumented agent performance monitoring and token/latency tracking

---

Appendix: What She Said

I handed Momentum to my wife on Sunday morning. By Sunday evening, she said:

"I don't know how to explain it, but having it pick ONE thing and tell me why in a nice voice... I actually did three tasks today. Usually I'd have done none just thinking about all of them."

The "smallest next action" feature was the breakthrough. Instead of "organize the garage" (overwhelming), it suggested "pick up one thing from the garage floor and decide keep/trash/donate." That she could do. And once she did one, she did another. That's the momentum.