Momentum

• 

• 

Inspiration

We built Momentum because we have all been that student.

You have a real idea — a startup, a project, a creative venture you genuinely believe in. You sit down to work on it. You open a blank page or type a prompt into a chatbot. And then one of two things happens: either the tool asks you to organize thoughts you do not yet know how to organize, or it hands you back a confident 12-step plan that ignores everything specific about your situation — your budget, your timeline, your actual skill level.

You close the tab. Another week passes.

We called this Overwhelmed Explorer Syndrome: the gap between having a high-potential idea and being able to take a single, concrete first step. It is not a motivation problem. It is a cognitive load problem. And no existing tool was built to solve it.

We wanted to build something that met users where they actually are — in the middle of the chaos, not after they had already sorted it out.

What it does

Momentum accepts a raw, unstructured brain dump from the user — no categories, no formatting required. It runs the input through a two-stage AI reasoning pipeline powered by the Gemini API.

Stage 1 identifies what critical information is missing before a realistic plan can be built. It surfaces 2–3 explicit assumptions, displays a confidence score with a plain-language reason, and presents these as editable cards the user must confirm before anything else happens. The system is hard-blocked from proceeding until every card is resolved.

Stage 2 combines the original input with the user's corrected constraints to generate a three-phase execution trajectory — Immediate, Execution, and Target Goal — and one hyper-specific 15-minute micro-task the user can start immediately.

The user reviews the output, edits any part of it, and clicks "Approve & Claim Task" to own their first step. A live 15-minute countdown timer then activates — enforcing the same time constraint the AI reasoned about. An on-device before/after comparison runs locally via Transformers.js, never transmitted to a server, giving the user actual evidence their cognitive state shifted. No data is stored between sessions.

How we built it

Momentum is a three-screen, single-session web application built on a decoupled frontend-backend architecture.

Screen 1 — Brain Dump: A minimalist, dark-themed interface built with Vanilla JS, HTML5, and Tailwind CSS. The user inputs an unstructured, emotionally raw brain dump — no categories, no prompting required. Before the text reaches the backend, a lightweight local embedding model (Xenova/all-MiniLM-L6-v2) runs entirely in the browser via Transformers.js inside a Web Worker, generating a heuristic metadata signal from the text without freezing the UI.

Screen 2 — Ambiguity Ledger: Our Python FastAPI backend, deployed on Render, receives the payload — including the local embedding metadata — and sends it to the Gemini API (gemini-2.5-flash-lite). A Stage 1 system prompt instructs the model to identify missing operational parameters — budget, timeline, technical background, access to tools — and return a structured JSON object (validated via Pydantic schemas) containing a confidence score (1–10) with a plain-language reason and 2–3 editable assumption cards. The UI state engine hard-blocks the application from proceeding until the user has explicitly confirmed or corrected every card.

Screen 3 — Action Horizon: Once the user resolves their assumptions, Stage 2 executes. The model receives the original brain dump plus the corrected human-validated constraints and returns a three-phase execution trajectory — Immediate, Execution, and Target Goal — and one hyper-specific micro-task completable in under 15 minutes. The user edits any part of the output before clicking "Approve & Claim Task" to own their first step. A live countdown timer immediately activates, and an on-device before/after comparison — powered by the same local Transformers.js model, never sent to a server — gives the user measurable evidence of their progress.

No data is stored between sessions. Everything runs within browser session state and stateless API calls.

Challenges we ran into

The Confidence Score Problem: A raw number on a screen means nothing without context. Getting the Stage 1 prompt to return a meaningful, plain-language reason alongside the score — one that genuinely reflected the input's specific ambiguity rather than a generic disclaimer — required extensive system prompt iteration.

The Gate Mechanic: Hard-blocking the UI from proceeding to Stage 2 until all assumption cards are resolved required strict frontend conditional state validation to ensure the block was enforced at the logic level, not just the visual level.

Frontend Recovery: A git submodule conflict wiped the entire frontend codebase mid-build. Rather than panic, the team paused, stepped away, and rebuilt from scratch — which ultimately produced cleaner, more intentional code than the original.

Scope Discipline: The hardest challenge was maintaining a minimalist footprint. Staying committed to three screens, two API calls, and one approved micro-task per session required constant prioritization throughout the sprint.

Accomplishments that we're proud of

The Ambiguity Ledger. What started as a responsible AI requirement became the core mechanic of the entire product. Building a gate that structurally blocks AI output until the human has resolved every assumption — and making that feel natural rather than frustrating in the UI — is something we're genuinely proud of.

We close the loop. After the user approves their task, a live 15-minute countdown timer activates — enforcing the same time constraint our AI reasons about. An on-device before/after comparison, powered by the same local Transformers.js model and never sent to a server, gives the user actual evidence their cognitive state shifted. Not a feel-good message — measurable proof that Momentum worked.

We're also proud of shipping a working, deployed, end-to-end product in six days as a fully virtual international team. The app runs a local embedding model in the browser via Transformers.js, connects to a FastAPI backend on Render, and delivers a clean three-screen experience — all without a database and all on free-tier tools.

And we're proud that the confidence score explains itself. It was the hardest prompt engineering problem we solved, and it's the moment in the demo that makes judges stop and pay attention.

What we learned

Our primary takeaway during the design phase was that an effective AI decision-support tool must prioritize knowing what it does not know over generating rapid answers.

We discovered that presenting machine-generated plans with absolute linguistic certainty reduces a user's critical engagement, leading to dangerous over-reliance. To combat this, we realized that responsible AI mechanics cannot be passive decorative disclaimers — they must be structural routing gates within the software architecture.

This led to our development of the Ambiguity Ledger. By forcing the machine to surface its internal operational assumptions and requiring the user to manually validate or correct those parameters before any milestone logic is rendered, we actively restore human sovereignty over the output. We learned that the highest utility an LLM can provide in a productivity context is not raw content generation, but choice-editing — filtering out long-term noise so a human can focus on a singular, immediate point of action.

What's next for Momentum

We want to expand beyond the single-session model. A lightweight session history would let returning users see how their thinking evolved over time — turning Momentum from a one-time unloading tool into a genuine thinking partner.

We also want to introduce collaborative mode — where two people can work through a shared idea together, with the Ambiguity Ledger surfacing assumptions from both perspectives before a joint plan is generated.

Longer term, we see Momentum serving researchers, community organizers, and early-stage NGO founders — anyone navigating a complex idea in a low-resource environment where false certainty from AI is especially costly.

Built With

• fastapi
• geminiapi
• html5
• javascript
• python
• tailwindcss
• transformer.js
• vercel